Redirecting to ../../lightbeam/struct.CodeGenSession.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/enum.ExecutionError.html b/api/lightbeam/enum.ExecutionError.html new file mode 100644 index 000000000000..a23200bf9bab --- /dev/null +++ b/api/lightbeam/enum.ExecutionError.html @@ -0,0 +1,33 @@ +impl Clone for ExecutionError[src]fn clone(&self) -> ExecutionError[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for ExecutionError[src]impl Debug for ExecutionError[src]impl Display for ExecutionError[src]impl Eq for ExecutionError[src]impl Error for ExecutionError[src]fn source(&self) -> Option<&(dyn Error + 'static)>1.30.0[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl PartialEq<ExecutionError> for ExecutionError[src]fn eq(&self, other: &ExecutionError) -> bool[src]#[must_use]
+fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for ExecutionError[src]impl StructuralPartialEq for ExecutionError[src]impl RefUnwindSafe for ExecutionErrorimpl Send for ExecutionErrorimpl Sync for ExecutionErrorimpl Unpin for ExecutionErrorimpl UnwindSafe for ExecutionErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> CloneAny for T where
T: Clone + Any, fn clone_any(&self) -> Box<dyn CloneAny + 'static>fn clone_any_send(&self) -> Box<dyn CloneAny + 'static + Send> where
T: Send, fn clone_any_sync(&self) -> Box<dyn CloneAny + 'static + Sync> where
T: Sync, fn clone_any_send_sync(&self) -> Box<dyn CloneAny + 'static + Send + Sync> where
T: Send + Sync, impl<T> DebugAny for T where
T: Any + Debug, impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<T> UnsafeAny for T where
T: Any, pub fn translate(data: &[u8]) -> Result<ExecutableModule, Error>
pub fn translate_function<M>(
session: &mut CodeGenSession<M>,
reloc_sink: &mut dyn RelocSink,
func_idx: u32,
body: &FunctionBody
) -> Result<(), Error> where
M: ModuleContext,
&'any M::Signature: Into<OpSig>,
Redirecting to ../../lightbeam/fn.translate_function.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/index.html b/api/lightbeam/index.html new file mode 100644 index 000000000000..753f1c3bf851 --- /dev/null +++ b/api/lightbeam/index.html @@ -0,0 +1,5 @@ +| CodeGenSession | |
| ExecutableModule | |
| TranslatedModule |
| ExecutionError |
| ModuleContext | |
| Signature |
| translate | |
| translate_function |
Redirecting to ../../lightbeam/enum.ExecutionError.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/module/fn.translate.html b/api/lightbeam/module/fn.translate.html new file mode 100644 index 000000000000..e31e0e0826cc --- /dev/null +++ b/api/lightbeam/module/fn.translate.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../lightbeam/fn.translate.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/module/struct.ExecutableModule.html b/api/lightbeam/module/struct.ExecutableModule.html new file mode 100644 index 000000000000..ea1e0b9990ac --- /dev/null +++ b/api/lightbeam/module/struct.ExecutableModule.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../lightbeam/struct.ExecutableModule.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/module/struct.TranslatedModule.html b/api/lightbeam/module/struct.TranslatedModule.html new file mode 100644 index 000000000000..51243b5ae32e --- /dev/null +++ b/api/lightbeam/module/struct.TranslatedModule.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../lightbeam/struct.TranslatedModule.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/module/trait.ModuleContext.html b/api/lightbeam/module/trait.ModuleContext.html new file mode 100644 index 000000000000..2ee21ee27257 --- /dev/null +++ b/api/lightbeam/module/trait.ModuleContext.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../lightbeam/trait.ModuleContext.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/module/trait.Signature.html b/api/lightbeam/module/trait.Signature.html new file mode 100644 index 000000000000..2a2fa08abd90 --- /dev/null +++ b/api/lightbeam/module/trait.Signature.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../lightbeam/trait.Signature.html...
+ + + \ No newline at end of file diff --git a/api/lightbeam/sidebar-items.js b/api/lightbeam/sidebar-items.js new file mode 100644 index 000000000000..731382f2c938 --- /dev/null +++ b/api/lightbeam/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"enum":[["ExecutionError",""]],"fn":[["translate",""],["translate_function",""]],"struct":[["CodeGenSession",""],["ExecutableModule",""],["TranslatedModule",""]],"trait":[["ModuleContext",""],["Signature",""]]}); \ No newline at end of file diff --git a/api/lightbeam/struct.CodeGenSession.html b/api/lightbeam/struct.CodeGenSession.html new file mode 100644 index 000000000000..aac27fda55ef --- /dev/null +++ b/api/lightbeam/struct.CodeGenSession.html @@ -0,0 +1,15 @@ +module_context: &'module Mop_offset_map: Vec<(AssemblyOffset, Box<dyn Display + Send + Sync>)>impl<'module, M> CodeGenSession<'module, M>[src]pub fn new(func_count: u32, module_context: &'module M) -> Self[src]pub fn new_context<'this>(
&'this mut self,
func_idx: u32,
reloc_sink: &'this mut dyn RelocSink
) -> Context<'this, M>[src]pub fn into_translated_code_section(
self
) -> Result<TranslatedCodeSection, Error>[src]impl<'module, M> !RefUnwindSafe for CodeGenSession<'module, M>impl<'module, M> !Send for CodeGenSession<'module, M>impl<'module, M> !Sync for CodeGenSession<'module, M>impl<'module, M> Unpin for CodeGenSession<'module, M>impl<'module, M> !UnwindSafe for CodeGenSession<'module, M>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<T> UnsafeAny for T where
T: Any, impl ExecutableModule[src]pub unsafe fn execute_func_unchecked<Args: FunctionArgs<T>, T>(
&self,
func_idx: u32,
args: Args
) -> T[src]Executes the function identified by func_idx.
Executes the function without checking the argument types. +This can cause undefined memory to be accessed.
+pub fn execute_func<Args: FunctionArgs<T> + TypeList, T: TypeList>(
&self,
func_idx: u32,
args: Args
) -> Result<T, ExecutionError>[src]pub fn disassemble(&self)[src]impl !RefUnwindSafe for ExecutableModuleimpl Send for ExecutableModuleimpl Sync for ExecutableModuleimpl Unpin for ExecutableModuleimpl !UnwindSafe for ExecutableModuleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<T> UnsafeAny for T where
T: Any, impl TranslatedModule[src]pub fn instantiate(self) -> ExecutableModule[src]pub fn disassemble(&self)[src]impl Default for TranslatedModule[src]fn default() -> TranslatedModule[src]impl !RefUnwindSafe for TranslatedModuleimpl Send for TranslatedModuleimpl Sync for TranslatedModuleimpl Unpin for TranslatedModuleimpl !UnwindSafe for TranslatedModuleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<T> UnsafeAny for T where
T: Any, type Signature: Signaturetype GlobalType: SigTypefn vmctx_vmglobal_definition(&self, index: u32) -> u32fn vmctx_vmglobal_import_from(&self, index: u32) -> u32fn vmctx_vmmemory_import_from(&self, memory_index: u32) -> u32fn vmctx_vmmemory_definition(&self, defined_memory_index: u32) -> u32fn vmctx_vmmemory_definition_base(&self, defined_memory_index: u32) -> u32fn vmctx_vmmemory_definition_current_length(
&self,
defined_memory_index: u32
) -> u32fn vmmemory_definition_base(&self) -> u8fn vmmemory_definition_current_length(&self) -> u8fn vmctx_vmtable_import_from(&self, table_index: u32) -> u32fn vmctx_vmtable_definition(&self, defined_table_index: u32) -> u32fn vmctx_vmtable_definition_base(&self, defined_table_index: u32) -> u32fn vmctx_vmtable_definition_current_elements(
&self,
defined_table_index: u32
) -> u32fn vmctx_vmfunction_import_body(&self, func_index: u32) -> u32fn vmctx_vmfunction_import_vmctx(&self, func_index: u32) -> u32fn vmtable_definition_base(&self) -> u8fn vmtable_definition_current_elements(&self) -> u8fn vmctx_vmshared_signature_id(&self, signature_idx: u32) -> u32fn vmcaller_checked_anyfunc_type_index(&self) -> u8fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8fn vmcaller_checked_anyfunc_vmctx(&self) -> u8fn size_of_vmcaller_checked_anyfunc(&self) -> u8fn defined_table_index(&self, table_index: u32) -> Option<u32>fn defined_memory_index(&self, index: u32) -> Option<u32>fn defined_global_index(&self, global_index: u32) -> Option<u32>fn global_type(&self, global_index: u32) -> &Self::GlobalTypefn func_type_index(&self, func_idx: u32) -> u32fn signature(&self, index: u32) -> &Self::Signaturefn func_index(&self, defined_func_index: u32) -> u32fn defined_func_index(&self, func_index: u32) -> Option<u32>fn defined_func_type(&self, defined_func_idx: u32) -> &Self::Signaturefn func_type(&self, func_idx: u32) -> &Self::Signaturefn emit_memory_bounds_check(&self) -> booltype Type: SigTypeimpl Signature for CraneliftSignature[src]impl Signature for FuncType[src]| "+""+(item.is_alias===true?(""+item.alias+" - see "):"")+item.displayPath+""+name+" | "+""+""+escape(item.desc)+" |
"+code.outerHTML+" |
fn:) to \
+ restrict the search to a given type.","Accepted types are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ * -> vec)","Search multiple things at once by splitting your query with comma (e.g., \
+ str,u8 or String,struct:Vec,test)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 + 100 + 101 + 102 + 103 + 104 + 105 + 106 + 107 + 108 + 109 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 120 + 121 + 122 + 123 + 124 + 125 + 126 + 127 + 128 + 129 + 130 + 131 + 132 + 133 + 134 + 135 + 136 + 137 + 138 + 139 + 140 + 141 + 142 + 143 + 144 + 145 + 146 + 147 + 148 + 149 + 150 + 151 + 152 + 153 + 154 + 155 + 156 + 157 + 158 + 159 + 160 + 161 + 162 + 163 + 164 + 165 + 166 + 167 + 168 + 169 + 170 + 171 + 172 + 173 + 174 + 175 + 176 + 177 + 178 + 179 + 180 + 181 + 182 + 183 + 184 + 185 + 186 + 187 + 188 + 189 + 190 + 191 + 192 + 193 + 194 + 195 + 196 + 197 + 198 + 199 + 200 + 201 + 202 + 203 + 204 + 205 + 206 + 207 + 208 + 209 + 210 + 211 + 212 + 213 + 214 + 215 + 216 + 217 + 218 + 219 + 220 + 221 + 222 + 223 + 224 + 225 + 226 + 227 + 228 + 229 + 230 + 231 + 232 + 233 + 234 + 235 + 236 + 237 + 238 + 239 + 240 + 241 + 242 + 243 + 244 + 245 + 246 + 247 + 248 + 249 + 250 + 251 + 252 + 253 + 254 + 255 + 256 + 257 + 258 + 259 + 260 + 261 + 262 + 263 + 264 + 265 + 266 + 267 + 268 + 269 + 270 + 271 + 272 + 273 + 274 + 275 + 276 + 277 + 278 + 279 + 280 + 281 + 282 + 283 + 284 + 285 + 286 + 287 + 288 + 289 + 290 + 291 + 292 + 293 + 294 + 295 + 296 + 297 + 298 + 299 + 300 + 301 + 302 + 303 + 304 + 305 + 306 + 307 + 308 + 309 + 310 + 311 + 312 + 313 + 314 + 315 + 316 + 317 + 318 + 319 + 320 + 321 + 322 + 323 + 324 + 325 + 326 + 327 + 328 + 329 + 330 + 331 + 332 + 333 + 334 + 335 + 336 + 337 + 338 + 339 + 340 + 341 + 342 + 343 + 344 + 345 + 346 + 347 + 348 + 349 + 350 + 351 + 352 + 353 + 354 + 355 + 356 + 357 + 358 + 359 + 360 + 361 + 362 + 363 + 364 + 365 + 366 + 367 + 368 + 369 + 370 + 371 + 372 + 373 + 374 + 375 + 376 + 377 + 378 + 379 + 380 + 381 + 382 + 383 + 384 + 385 + 386 + 387 + 388 + 389 + 390 + 391 + 392 + 393 + 394 + 395 + 396 + 397 + 398 + 399 + 400 + 401 + 402 + 403 + 404 + 405 + 406 + 407 + 408 + 409 + 410 + 411 + 412 + 413 + 414 + 415 + 416 + 417 + 418 + 419 + 420 + 421 + 422 + 423 + 424 + 425 + 426 + 427 + 428 + 429 + 430 + 431 + 432 + 433 + 434 + 435 + 436 + 437 + 438 + 439 + 440 + 441 + 442 + 443 + 444 + 445 + 446 + 447 + 448 + 449 + 450 + 451 + 452 + 453 + 454 + 455 + 456 + 457 + 458 + 459 + 460 + 461 + 462 + 463 + 464 + 465 + 466 + 467 + 468 + 469 + 470 + 471 + 472 + 473 + 474 + 475 + 476 + 477 + 478 + 479 + 480 + 481 + 482 + 483 + 484 + 485 + 486 + 487 + 488 + 489 + 490 + 491 + 492 + 493 + 494 + 495 + 496 + 497 + 498 + 499 + 500 + 501 + 502 + 503 + 504 + 505 + 506 + 507 + 508 + 509 + 510 + 511 + 512 + 513 + 514 + 515 + 516 + 517 + 518 + 519 + 520 + 521 + 522 + 523 + 524 + 525 + 526 + 527 + 528 + 529 + 530 + 531 + 532 + 533 + 534 + 535 + 536 + 537 + 538 + 539 + 540 + 541 + 542 + 543 + 544 + 545 + 546 + 547 + 548 + 549 + 550 + 551 + 552 + 553 + 554 + 555 + 556 + 557 + 558 + 559 + 560 + 561 + 562 + 563 + 564 + 565 + 566 + 567 + 568 + 569 + 570 + 571 + 572 + 573 + 574 + 575 + 576 + 577 + 578 + 579 + 580 + 581 + 582 + 583 + 584 + 585 + 586 + 587 + 588 + 589 + 590 + 591 + 592 + 593 + 594 + 595 + 596 + 597 + 598 + 599 + 600 + 601 + 602 + 603 + 604 + 605 + 606 + 607 + 608 + 609 + 610 + 611 + 612 + 613 + 614 + 615 + 616 + 617 + 618 + 619 + 620 + 621 + 622 + 623 + 624 + 625 + 626 + 627 + 628 + 629 + 630 + 631 + 632 + 633 + 634 + 635 + 636 + 637 + 638 + 639 + 640 + 641 + 642 + 643 + 644 + 645 + 646 + 647 + 648 + 649 + 650 + 651 + 652 + 653 + 654 + 655 + 656 + 657 + 658 + 659 + 660 + 661 + 662 + 663 + 664 + 665 + 666 + 667 + 668 + 669 + 670 + 671 + 672 + 673 + 674 + 675 + 676 + 677 + 678 + 679 + 680 + 681 + 682 + 683 + 684 + 685 + 686 + 687 + 688 + 689 + 690 + 691 + 692 + 693 + 694 + 695 + 696 + 697 + 698 + 699 + 700 + 701 + 702 + 703 + 704 + 705 + 706 + 707 + 708 + 709 + 710 + 711 + 712 + 713 + 714 + 715 + 716 + 717 + 718 + 719 + 720 + 721 + 722 + 723 + 724 + 725 + 726 + 727 + 728 + 729 + 730 + 731 + 732 + 733 + 734 + 735 + 736 + 737 + 738 + 739 + 740 + 741 + 742 + 743 + 744 + 745 + 746 + 747 + 748 + 749 + 750 + 751 + 752 + 753 + 754 + 755 + 756 + 757 + 758 + 759 + 760 + 761 + 762 + 763 + 764 + 765 + 766 + 767 + 768 + 769 + 770 + 771 + 772 + 773 + 774 + 775 + 776 + 777 + 778 + 779 + 780 + 781 + 782 + 783 + 784 + 785 + 786 + 787 + 788 + 789 + 790 + 791 + 792 + 793 + 794 + 795 + 796 + 797 + 798 + 799 + 800 + 801 + 802 + 803 + 804 + 805 + 806 + 807 + 808 + 809 + 810 + 811 + 812 + 813 + 814 + 815 + 816 + 817 + 818 + 819 + 820 + 821 + 822 + 823 + 824 + 825 + 826 + 827 + 828 + 829 + 830 + 831 + 832 + 833 + 834 + 835 + 836 + 837 + 838 + 839 + 840 + 841 + 842 + 843 + 844 + 845 + 846 + 847 + 848 + 849 + 850 + 851 + 852 + 853 + 854 + 855 + 856 + 857 + 858 + 859 + 860 + 861 + 862 + 863 + 864 + 865 + 866 + 867 + 868 + 869 + 870 + 871 + 872 + 873 + 874 + 875 + 876 + 877 + 878 + 879 + 880 + 881 + 882 + 883 + 884 + 885 + 886 + 887 + 888 + 889 + 890 + 891 + 892 + 893 + 894 + 895 + 896 + 897 + 898 + 899 + 900 + 901 + 902 + 903 + 904 + 905 + 906 + 907 + 908 + 909 + 910 + 911 + 912 + 913 + 914 + 915 + 916 + 917 + 918 + 919 + 920 + 921 + 922 + 923 + 924 + 925 + 926 + 927 + 928 + 929 + 930 + 931 + 932 + 933 + 934 + 935 + 936 + 937 + 938 + 939 + 940 + 941 + 942 + 943 + 944 + 945 + 946 + 947 + 948 + 949 + 950 + 951 + 952 + 953 + 954 + 955 + 956 + 957 + 958 + 959 + 960 + 961 + 962 + 963 + 964 + 965 + 966 + 967 + 968 + 969 + 970 + 971 + 972 + 973 + 974 + 975 + 976 + 977 + 978 + 979 + 980 + 981 + 982 + 983 + 984 + 985 + 986 + 987 + 988 + 989 + 990 + 991 + 992 + 993 + 994 + 995 + 996 + 997 + 998 + 999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +1093 +1094 +1095 +1096 +1097 +1098 +1099 +1100 +1101 +1102 +1103 +1104 +1105 +1106 +1107 +1108 +1109 +1110 +1111 +1112 +1113 +1114 +1115 +1116 +1117 +1118 +1119 +1120 +1121 +1122 +1123 +1124 +1125 +1126 +1127 +1128 +1129 +1130 +1131 +1132 +1133 +1134 +1135 +1136 +1137 +1138 +1139 +1140 +1141 +1142 +1143 +1144 +1145 +1146 +1147 +1148 +1149 +1150 +1151 +1152 +1153 +1154 +1155 +1156 +1157 +1158 +1159 +1160 +1161 +1162 +1163 +1164 +1165 +1166 +1167 +1168 +1169 +1170 +1171 +1172 +1173 +1174 +1175 +1176 +1177 +1178 +1179 +1180 +1181 +1182 +1183 +1184 +1185 +1186 +1187 +1188 +1189 +1190 +1191 +1192 +1193 +1194 +1195 +1196 +1197 +1198 +1199 +1200 +1201 +1202 +1203 +1204 +1205 +1206 +1207 +1208 +1209 +1210 +1211 +1212 +1213 +1214 +1215 +1216 +1217 +1218 +1219 +1220 +1221 +1222 +1223 +1224 +1225 +1226 +1227 +1228 +1229 +1230 +1231 +1232 +1233 +1234 +1235 +1236 +1237 +1238 +1239 +1240 +1241 +1242 +1243 +1244 +1245 +1246 +1247 +1248 +1249 +1250 +1251 +1252 +1253 +1254 +1255 +1256 +1257 +1258 +1259 +1260 +1261 +1262 +1263 +1264 +1265 +1266 +1267 +1268 +1269 +1270 +1271 +1272 +1273 +1274 +1275 +1276 +1277 +1278 +1279 +1280 +1281 +1282 +1283 +1284 +1285 +1286 +1287 +1288 +1289 +1290 +1291 +1292 +1293 +1294 +1295 +1296 +1297 +1298 +1299 +1300 +1301 +1302 +1303 +1304 +1305 +1306 +1307 +1308 +1309 +1310 +1311 +1312 +1313 +1314 +1315 +1316 +1317 +1318 +1319 +1320 +1321 +1322 +1323 +1324 +1325 +1326 +1327 +1328 +1329 +1330 +1331 +1332 +1333 +1334 +1335 +1336 +1337 +1338 +1339 +1340 +1341 +1342 +1343 +1344 +1345 +1346 +1347 +1348 +1349 +1350 +1351 +1352 +1353 +1354 +1355 +1356 +1357 +1358 +1359 +1360 +1361 +1362 +1363 +1364 +1365 +1366 +1367 +1368 +1369 +1370 +1371 +1372 +1373 +1374 +1375 +1376 +1377 +1378 +1379 +1380 +1381 +1382 +1383 +1384 +1385 +1386 +1387 +1388 +1389 +1390 +1391 +1392 +1393 +1394 +1395 +1396 +1397 +1398 +1399 +1400 +1401 +1402 +1403 +1404 +1405 +1406 +1407 +1408 +1409 +1410 +1411 +1412 +1413 +1414 +1415 +1416 +1417 +1418 +1419 +1420 +1421 +1422 +1423 +1424 +1425 +1426 +1427 +1428 +1429 +1430 +1431 +1432 +1433 +1434 +1435 +1436 +1437 +1438 +1439 +1440 +1441 +1442 +1443 +1444 +1445 +1446 +1447 +1448 +1449 +1450 +1451 +1452 +1453 +1454 +1455 +1456 +1457 +1458 +1459 +1460 +1461 +1462 +1463 +1464 +1465 +1466 +1467 +1468 +1469 +1470 +1471 +1472 +1473 +1474 +1475 +1476 +1477 +1478 +1479 +1480 +1481 +1482 +1483 +1484 +1485 +1486 +1487 +1488 +1489 +1490 +1491 +1492 +1493 +1494 +1495 +1496 +1497 +1498 +1499 +1500 +1501 +1502 +1503 +1504 +1505 +1506 +1507 +1508 +1509 +1510 +1511 +1512 +1513 +1514 +1515 +1516 +1517 +1518 +1519 +1520 +1521 +1522 +1523 +1524 +1525 +1526 +1527 +1528 +1529 +1530 +1531 +1532 +1533 +1534 +1535 +1536 +1537 +1538 +1539 +1540 +1541 +1542 +1543 +1544 +1545 +1546 +1547 +1548 +1549 +1550 +1551 +1552 +1553 +1554 +1555 +1556 +1557 +1558 +1559 +1560 +1561 +1562 +1563 +1564 +1565 +1566 +1567 +1568 +1569 +1570 +1571 +1572 +1573 +1574 +1575 +1576 +1577 +1578 +1579 +1580 +1581 +1582 +1583 +1584 +1585 +1586 +1587 +1588 +1589 +1590 +1591 +1592 +1593 +1594 +1595 +1596 +1597 +1598 +1599 +1600 +1601 +1602 +1603 +1604 +1605 +1606 +1607 +1608 +1609 +1610 +1611 +1612 +1613 +1614 +1615 +1616 +1617 +1618 +1619 +1620 +1621 +1622 +1623 +1624 +1625 +1626 +1627 +1628 +1629 +1630 +1631 +1632 +1633 +1634 +1635 +1636 +1637 +1638 +1639 +1640 +1641 +1642 +1643 +1644 +1645 +1646 +1647 +1648 +1649 +1650 +1651 +1652 +1653 +1654 +1655 +1656 +1657 +1658 +1659 +1660 +1661 +1662 +1663 +1664 +1665 +1666 +1667 +1668 +1669 +1670 +1671 +1672 +1673 +1674 +1675 +1676 +1677 +1678 +1679 +1680 +1681 +1682 +1683 +1684 +1685 +1686 +1687 +1688 +1689 +1690 +1691 +1692 +1693 +1694 +1695 +1696 +1697 +1698 +1699 +1700 +1701 +1702 +1703 +1704 +1705 +1706 +1707 +1708 +1709 +1710 +1711 +1712 +1713 +1714 +1715 +1716 +1717 +1718 +1719 +1720 +1721 +1722 +1723 +1724 +1725 +1726 +1727 +1728 +1729 +1730 +1731 +1732 +1733 +1734 +1735 +1736 +1737 +1738 +1739 +1740 +1741 +1742 +1743 +1744 +1745 +1746 +1747 +1748 +1749 +1750 +1751 +1752 +1753 +1754 +1755 +1756 +1757 +1758 +1759 +1760 +1761 +1762 +1763 +1764 +1765 +1766 +1767 +1768 +1769 +1770 +1771 +1772 +1773 +1774 +1775 +1776 +1777 +1778 +1779 +1780 +1781 +1782 +1783 +1784 +1785 +1786 +1787 +1788 +1789 +1790 +1791 +1792 +1793 +1794 +1795 +1796 +1797 +1798 +1799 +1800 +1801 +1802 +1803 +1804 +1805 +1806 +1807 +1808 +1809 +1810 +1811 +1812 +1813 +1814 +1815 +1816 +1817 +1818 +1819 +1820 +1821 +1822 +1823 +1824 +1825 +1826 +1827 +1828 +1829 +1830 +1831 +1832 +1833 +1834 +1835 +1836 +1837 +1838 +1839 +1840 +1841 +1842 +1843 +1844 +1845 +1846 +1847 +1848 +1849 +1850 +1851 +1852 +1853 +1854 +1855 +1856 +1857 +1858 +1859 +1860 +1861 +1862 +1863 +1864 +1865 +1866 +1867 +1868 +1869 +1870 +1871 +1872 +1873 +1874 +1875 +1876 +1877 +1878 +1879 +1880 +1881 +1882 +1883 +1884 +1885 +1886 +1887 +1888 +1889 +1890 +1891 +1892 +1893 +1894 +1895 +1896 +1897 +1898 +1899 +1900 +1901 +1902 +1903 +1904 +1905 +1906 +1907 +1908 +1909 +1910 +1911 +1912 +1913 +1914 +1915 +1916 +1917 +1918 +1919 +1920 +1921 +1922 +1923 +1924 +1925 +1926 +1927 +1928 +1929 +1930 +1931 +1932 +1933 +1934 +1935 +1936 +1937 +1938 +1939 +1940 +1941 +1942 +1943 +1944 +1945 +1946 +1947 +1948 +1949 +1950 +1951 +1952 +1953 +1954 +1955 +1956 +1957 +1958 +1959 +1960 +1961 +1962 +1963 +1964 +1965 +1966 +1967 +1968 +1969 +1970 +1971 +1972 +1973 +1974 +1975 +1976 +1977 +1978 +1979 +1980 +1981 +1982 +1983 +1984 +1985 +1986 +1987 +1988 +1989 +1990 +1991 +1992 +1993 +1994 +1995 +1996 +1997 +1998 +1999 +2000 +2001 +2002 +2003 +2004 +2005 +2006 +2007 +2008 +2009 +2010 +2011 +2012 +2013 +2014 +2015 +2016 +2017 +2018 +2019 +2020 +2021 +2022 +2023 +2024 +2025 +2026 +2027 +2028 +2029 +2030 +2031 +2032 +2033 +2034 +2035 +2036 +2037 +2038 +2039 +2040 +2041 +2042 +2043 +2044 +2045 +2046 +2047 +2048 +2049 +2050 +2051 +2052 +2053 +2054 +2055 +2056 +2057 +2058 +2059 +2060 +2061 +2062 +2063 +2064 +2065 +2066 +2067 +2068 +2069 +2070 +2071 +2072 +2073 +2074 +2075 +2076 +2077 +2078 +2079 +2080 +2081 +2082 +2083 +2084 +2085 +2086 +2087 +2088 +2089 +2090 +2091 +2092 +2093 +2094 +2095 +2096 +2097 +2098 +2099 +2100 +2101 +2102 +2103 +2104 +2105 +2106 +2107 +2108 +2109 +2110 +2111 +2112 +2113 +2114 +2115 +2116 +2117 +2118 +2119 +2120 +2121 +2122 +2123 +2124 +2125 +2126 +2127 +2128 +2129 +2130 +2131 +2132 +2133 +2134 +2135 +2136 +2137 +2138 +2139 +2140 +2141 +2142 +2143 +2144 +2145 +2146 +2147 +2148 +2149 +2150 +2151 +2152 +2153 +2154 +2155 +2156 +2157 +2158 +2159 +2160 +2161 +2162 +2163 +2164 +2165 +2166 +2167 +2168 +2169 +2170 +2171 +2172 +2173 +2174 +2175 +2176 +2177 +2178 +2179 +2180 +2181 +2182 +2183 +2184 +2185 +2186 +2187 +2188 +2189 +2190 +2191 +2192 +2193 +2194 +2195 +2196 +2197 +2198 +2199 +2200 +2201 +2202 +2203 +2204 +2205 +2206 +2207 +2208 +2209 +2210 +2211 +2212 +2213 +2214 +2215 +2216 +2217 +2218 +2219 +2220 +2221 +2222 +2223 +2224 +2225 +2226 +2227 +2228 +2229 +2230 +2231 +2232 +2233 +2234 +2235 +2236 +2237 +2238 +2239 +2240 +2241 +2242 +2243 +2244 +2245 +2246 +2247 +2248 +2249 +2250 +2251 +2252 +2253 +2254 +2255 +2256 +2257 +2258 +2259 +2260 +2261 +2262 +2263 +2264 +2265 +2266 +2267 +2268 +2269 +2270 +2271 +2272 +2273 +2274 +2275 +2276 +2277 +2278 +2279 +2280 +2281 +2282 +2283 +2284 +2285 +2286 +2287 +2288 +2289 +2290 +2291 +2292 +2293 +2294 +2295 +2296 +2297 +2298 +2299 +2300 +2301 +2302 +2303 +2304 +2305 +2306 +2307 +2308 +2309 +2310 +2311 +2312 +2313 +2314 +2315 +2316 +2317 +2318 +2319 +2320 +2321 +2322 +2323 +2324 +2325 +2326 +2327 +2328 +2329 +2330 +2331 +2332 +2333 +2334 +2335 +2336 +2337 +2338 +2339 +2340 +2341 +2342 +2343 +2344 +2345 +2346 +2347 +2348 +2349 +2350 +2351 +2352 +2353 +2354 +2355 +2356 +2357 +2358 +2359 +2360 +2361 +2362 +2363 +2364 +2365 +2366 +2367 +2368 +2369 +2370 +2371 +2372 +2373 +2374 +2375 +2376 +2377 +2378 +2379 +2380 +2381 +2382 +2383 +2384 +2385 +2386 +2387 +2388 +2389 +2390 +2391 +2392 +2393 +2394 +2395 +2396 +2397 +2398 +2399 +2400 +2401 +2402 +2403 +2404 +2405 +2406 +2407 +2408 +2409 +2410 +2411 +2412 +2413 +2414 +2415 +2416 +2417 +2418 +2419 +2420 +2421 +2422 +2423 +2424 +2425 +2426 +2427 +2428 +2429 +2430 +2431 +2432 +2433 +2434 +2435 +2436 +2437 +2438 +2439 +2440 +2441 +2442 +2443 +2444 +2445 +2446 +2447 +2448 +2449 +2450 +2451 +2452 +2453 +2454 +2455 +2456 +2457 +2458 +2459 +2460 +2461 +2462 +2463 +2464 +2465 +2466 +2467 +2468 +2469 +2470 +2471 +2472 +2473 +2474 +2475 +2476 +2477 +2478 +2479 +2480 +2481 +2482 +2483 +2484 +2485 +2486 +2487 +2488 +2489 +2490 +2491 +2492 +2493 +2494 +2495 +2496 +2497 +2498 +2499 +2500 +2501 +2502 +2503 +2504 +2505 +2506 +2507 +2508 +2509 +2510 +2511 +2512 +2513 +2514 +2515 +2516 +2517 +2518 +2519 +2520 +2521 +2522 +2523 +2524 +2525 +2526 +2527 +2528 +2529 +2530 +2531 +2532 +2533 +2534 +2535 +2536 +2537 +2538 +2539 +2540 +2541 +2542 +2543 +2544 +2545 +2546 +2547 +2548 +2549 +2550 +2551 +2552 +2553 +2554 +2555 +2556 +2557 +2558 +2559 +2560 +2561 +2562 +2563 +2564 +2565 +2566 +2567 +2568 +2569 +2570 +2571 +2572 +2573 +2574 +2575 +2576 +2577 +2578 +2579 +2580 +2581 +2582 +2583 +2584 +2585 +2586 +2587 +2588 +2589 +2590 +2591 +2592 +2593 +2594 +2595 +2596 +2597 +2598 +2599 +2600 +2601 +2602 +2603 +2604 +2605 +2606 +2607 +2608 +2609 +2610 +2611 +2612 +2613 +2614 +2615 +2616 +2617 +2618 +2619 +2620 +2621 +2622 +2623 +2624 +2625 +2626 +2627 +2628 +2629 +2630 +2631 +2632 +2633 +2634 +2635 +2636 +2637 +2638 +2639 +2640 +2641 +2642 +2643 +2644 +2645 +2646 +2647 +2648 +2649 +2650 +2651 +2652 +2653 +2654 +2655 +2656 +2657 +2658 +2659 +2660 +2661 +2662 +2663 +2664 +2665 +2666 +2667 +2668 +2669 +2670 +2671 +2672 +2673 +2674 +2675 +2676 +2677 +2678 +2679 +2680 +2681 +2682 +2683 +2684 +2685 +2686 +2687 +2688 +2689 +2690 +2691 +2692 +2693 +2694 +2695 +2696 +2697 +2698 +2699 +2700 +2701 +2702 +2703 +2704 +2705 +2706 +2707 +2708 +2709 +2710 +2711 +2712 +2713 +2714 +2715 +2716 +2717 +2718 +2719 +2720 +2721 +2722 +2723 +2724 +2725 +2726 +2727 +2728 +2729 +2730 +2731 +2732 +2733 +2734 +2735 +2736 +2737 +2738 +2739 +2740 +2741 +2742 +2743 +2744 +2745 +2746 +2747 +2748 +2749 +2750 +2751 +2752 +2753 +2754 +2755 +2756 +2757 +2758 +2759 +2760 +2761 +2762 +2763 +2764 +2765 +2766 +2767 +2768 +2769 +2770 +2771 +2772 +2773 +2774 +2775 +2776 +2777 +2778 +2779 +2780 +2781 +2782 +2783 +2784 +2785 +2786 +2787 +2788 +2789 +2790 +2791 +2792 +2793 +2794 +2795 +2796 +2797 +2798 +2799 +2800 +2801 +2802 +2803 +2804 +2805 +2806 +2807 +2808 +2809 +2810 +2811 +2812 +2813 +2814 +2815 +2816 +2817 +2818 +2819 +2820 +2821 +2822 +2823 +2824 +2825 +2826 +2827 +2828 +2829 +2830 +2831 +2832 +2833 +2834 +2835 +2836 +2837 +2838 +2839 +2840 +2841 +2842 +2843 +2844 +2845 +2846 +2847 +2848 +2849 +2850 +2851 +2852 +2853 +2854 +2855 +2856 +2857 +2858 +2859 +2860 +2861 +2862 +2863 +2864 +2865 +2866 +2867 +2868 +2869 +2870 +2871 +2872 +2873 +2874 +2875 +2876 +2877 +2878 +2879 +2880 +2881 +2882 +2883 +2884 +2885 +2886 +2887 +2888 +2889 +2890 +2891 +2892 +2893 +2894 +2895 +2896 +2897 +2898 +2899 +2900 +2901 +2902 +2903 +2904 +2905 +2906 +2907 +2908 +2909 +2910 +2911 +2912 +2913 +2914 +2915 +2916 +2917 +2918 +2919 +2920 +2921 +2922 +2923 +2924 +2925 +2926 +2927 +2928 +2929 +2930 +2931 +2932 +2933 +2934 +2935 +2936 +2937 +2938 +2939 +2940 +2941 +2942 +2943 +2944 +2945 +2946 +2947 +2948 +2949 +2950 +2951 +2952 +2953 +2954 +2955 +2956 +2957 +2958 +2959 +2960 +2961 +2962 +2963 +2964 +2965 +2966 +2967 +2968 +2969 +2970 +2971 +2972 +2973 +2974 +2975 +2976 +2977 +2978 +2979 +2980 +2981 +2982 +2983 +2984 +2985 +2986 +2987 +2988 +2989 +2990 +2991 +2992 +2993 +2994 +2995 +2996 +2997 +2998 +2999 +3000 +3001 +3002 +3003 +3004 +3005 +3006 +3007 +3008 +3009 +3010 +3011 +3012 +3013 +3014 +3015 +3016 +3017 +3018 +3019 +3020 +3021 +3022 +3023 +3024 +3025 +3026 +3027 +3028 +3029 +3030 +3031 +3032 +3033 +3034 +3035 +3036 +3037 +3038 +3039 +3040 +3041 +3042 +3043 +3044 +3045 +3046 +3047 +3048 +3049 +3050 +3051 +3052 +3053 +3054 +3055 +3056 +3057 +3058 +3059 +3060 +3061 +3062 +3063 +3064 +3065 +3066 +3067 +3068 +3069 +3070 +3071 +3072 +3073 +3074 +3075 +3076 +3077 +3078 +3079 +3080 +3081 +3082 +3083 +3084 +3085 +3086 +3087 +3088 +3089 +3090 +3091 +3092 +3093 +3094 +3095 +3096 +3097 +3098 +3099 +3100 +3101 +3102 +3103 +3104 +3105 +3106 +3107 +3108 +3109 +3110 +3111 +3112 +3113 +3114 +3115 +3116 +3117 +3118 +3119 +3120 +3121 +3122 +3123 +3124 +3125 +3126 +3127 +3128 +3129 +3130 +3131 +3132 +3133 +3134 +3135 +3136 +3137 +3138 +3139 +3140 +3141 +3142 +3143 +3144 +3145 +3146 +3147 +3148 +3149 +3150 +3151 +3152 +3153 +3154 +3155 +3156 +3157 +3158 +3159 +3160 +3161 +3162 +3163 +3164 +3165 +3166 +3167 +3168 +3169 +3170 +3171 +3172 +3173 +3174 +3175 +3176 +3177 +3178 +3179 +3180 +3181 +3182 +3183 +3184 +3185 +3186 +3187 +3188 +3189 +3190 +3191 +3192 +3193 +3194 +3195 +3196 +3197 +3198 +3199 +3200 +3201 +3202 +3203 +3204 +3205 +3206 +3207 +3208 +3209 +3210 +3211 +3212 +3213 +3214 +3215 +3216 +3217 +3218 +3219 +3220 +3221 +3222 +3223 +3224 +3225 +3226 +3227 +3228 +3229 +3230 +3231 +3232 +3233 +3234 +3235 +3236 +3237 +3238 +3239 +3240 +3241 +3242 +3243 +3244 +3245 +3246 +3247 +3248 +3249 +3250 +3251 +3252 +3253 +3254 +3255 +3256 +3257 +3258 +3259 +3260 +3261 +3262 +3263 +3264 +3265 +3266 +3267 +3268 +3269 +3270 +3271 +3272 +3273 +3274 +3275 +3276 +3277 +3278 +3279 +3280 +3281 +3282 +3283 +3284 +3285 +3286 +3287 +3288 +3289 +3290 +3291 +3292 +3293 +3294 +3295 +3296 +3297 +3298 +3299 +3300 +3301 +3302 +3303 +3304 +3305 +3306 +3307 +3308 +3309 +3310 +3311 +3312 +3313 +3314 +3315 +3316 +3317 +3318 +3319 +3320 +3321 +3322 +3323 +3324 +3325 +3326 +3327 +3328 +3329 +3330 +3331 +3332 +3333 +3334 +3335 +3336 +3337 +3338 +3339 +3340 +3341 +3342 +3343 +3344 +3345 +3346 +3347 +3348 +3349 +3350 +3351 +3352 +3353 +3354 +3355 +3356 +3357 +3358 +3359 +3360 +3361 +3362 +3363 +3364 +3365 +3366 +3367 +3368 +3369 +3370 +3371 +3372 +3373 +3374 +3375 +3376 +3377 +3378 +3379 +3380 +3381 +3382 +3383 +3384 +3385 +3386 +3387 +3388 +3389 +3390 +3391 +3392 +3393 +3394 +3395 +3396 +3397 +3398 +3399 +3400 +3401 +3402 +3403 +3404 +3405 +3406 +3407 +3408 +3409 +3410 +3411 +3412 +3413 +3414 +3415 +3416 +3417 +3418 +3419 +3420 +3421 +3422 +3423 +3424 +3425 +3426 +3427 +3428 +3429 +3430 +3431 +3432 +3433 +3434 +3435 +3436 +3437 +3438 +3439 +3440 +3441 +3442 +3443 +3444 +3445 +3446 +3447 +3448 +3449 +3450 +3451 +3452 +3453 +3454 +3455 +3456 +3457 +3458 +3459 +3460 +3461 +3462 +3463 +3464 +3465 +3466 +3467 +3468 +3469 +3470 +3471 +3472 +3473 +3474 +3475 +3476 +3477 +3478 +3479 +3480 +3481 +3482 +3483 +3484 +3485 +3486 +3487 +3488 +3489 +3490 +3491 +3492 +3493 +3494 +3495 +3496 +3497 +3498 +3499 +3500 +3501 +3502 +3503 +3504 +3505 +3506 +3507 +3508 +3509 +3510 +3511 +3512 +3513 +3514 +3515 +3516 +3517 +3518 +3519 +3520 +3521 +3522 +3523 +3524 +3525 +3526 +3527 +3528 +3529 +3530 +3531 +3532 +3533 +3534 +3535 +3536 +3537 +3538 +3539 +3540 +3541 +3542 +3543 +3544 +3545 +3546 +3547 +3548 +3549 +3550 +3551 +3552 +3553 +3554 +3555 +3556 +3557 +3558 +3559 +3560 +3561 +3562 +3563 +3564 +3565 +3566 +3567 +3568 +3569 +3570 +3571 +3572 +3573 +3574 +3575 +3576 +3577 +3578 +3579 +3580 +3581 +3582 +3583 +3584 +3585 +3586 +3587 +3588 +3589 +3590 +3591 +3592 +3593 +3594 +3595 +3596 +3597 +3598 +3599 +3600 +3601 +3602 +3603 +3604 +3605 +3606 +3607 +3608 +3609 +3610 +3611 +3612 +3613 +3614 +3615 +3616 +3617 +3618 +3619 +3620 +3621 +3622 +3623 +3624 +3625 +3626 +3627 +3628 +3629 +3630 +3631 +3632 +3633 +3634 +3635 +3636 +3637 +3638 +3639 +3640 +3641 +3642 +3643 +3644 +3645 +3646 +3647 +3648 +3649 +3650 +3651 +3652 +3653 +3654 +3655 +3656 +3657 +3658 +3659 +3660 +3661 +3662 +3663 +3664 +3665 +3666 +3667 +3668 +3669 +3670 +3671 +3672 +3673 +3674 +3675 +3676 +3677 +3678 +3679 +3680 +3681 +3682 +3683 +3684 +3685 +3686 +3687 +3688 +3689 +3690 +3691 +3692 +3693 +3694 +3695 +3696 +3697 +3698 +3699 +3700 +3701 +3702 +3703 +3704 +3705 +3706 +3707 +3708 +3709 +3710 +3711 +3712 +3713 +3714 +3715 +3716 +3717 +3718 +3719 +3720 +3721 +3722 +3723 +3724 +3725 +3726 +3727 +3728 +3729 +3730 +3731 +3732 +3733 +3734 +3735 +3736 +3737 +3738 +3739 +3740 +3741 +3742 +3743 +3744 +3745 +3746 +3747 +3748 +3749 +3750 +3751 +3752 +3753 +3754 +3755 +3756 +3757 +3758 +3759 +3760 +3761 +3762 +3763 +3764 +3765 +3766 +3767 +3768 +3769 +3770 +3771 +3772 +3773 +3774 +3775 +3776 +3777 +3778 +3779 +3780 +3781 +3782 +3783 +3784 +3785 +3786 +3787 +3788 +3789 +3790 +3791 +3792 +3793 +3794 +3795 +3796 +3797 +3798 +3799 +3800 +3801 +3802 +3803 +3804 +3805 +3806 +3807 +3808 +3809 +3810 +3811 +3812 +3813 +3814 +3815 +3816 +3817 +3818 +3819 +3820 +3821 +3822 +3823 +3824 +3825 +3826 +3827 +3828 +3829 +3830 +3831 +3832 +3833 +3834 +3835 +3836 +3837 +3838 +3839 +3840 +3841 +3842 +3843 +3844 +3845 +3846 +3847 +3848 +3849 +3850 +3851 +3852 +3853 +3854 +3855 +3856 +3857 +3858 +3859 +3860 +3861 +3862 +3863 +3864 +3865 +3866 +3867 +3868 +3869 +3870 +3871 +3872 +3873 +3874 +3875 +3876 +3877 +3878 +3879 +3880 +3881 +3882 +3883 +3884 +3885 +3886 +3887 +3888 +3889 +3890 +3891 +3892 +3893 +3894 +3895 +3896 +3897 +3898 +3899 +3900 +3901 +3902 +3903 +3904 +3905 +3906 +3907 +3908 +3909 +3910 +3911 +3912 +3913 +3914 +3915 +3916 +3917 +3918 +3919 +3920 +3921 +3922 +3923 +3924 +3925 +3926 +3927 +3928 +3929 +3930 +3931 +3932 +3933 +3934 +3935 +3936 +3937 +3938 +3939 +3940 +3941 +3942 +3943 +3944 +3945 +3946 +3947 +3948 +3949 +3950 +3951 +3952 +3953 +3954 +3955 +3956 +3957 +3958 +3959 +3960 +3961 +3962 +3963 +3964 +3965 +3966 +3967 +3968 +3969 +3970 +3971 +3972 +3973 +3974 +3975 +3976 +3977 +3978 +3979 +3980 +3981 +3982 +3983 +3984 +3985 +3986 +3987 +3988 +3989 +3990 +3991 +3992 +3993 +3994 +3995 +3996 +3997 +3998 +3999 +4000 +4001 +4002 +4003 +4004 +4005 +4006 +4007 +4008 +4009 +4010 +4011 +4012 +4013 +4014 +4015 +4016 +4017 +4018 +4019 +4020 +4021 +4022 +4023 +4024 +4025 +4026 +4027 +4028 +4029 +4030 +4031 +4032 +4033 +4034 +4035 +4036 +4037 +4038 +4039 +4040 +4041 +4042 +4043 +4044 +4045 +4046 +4047 +4048 +4049 +4050 +4051 +4052 +4053 +4054 +4055 +4056 +4057 +4058 +4059 +4060 +4061 +4062 +4063 +4064 +4065 +4066 +4067 +4068 +4069 +4070 +4071 +4072 +4073 +4074 +4075 +4076 +4077 +4078 +4079 +4080 +4081 +4082 +4083 +4084 +4085 +4086 +4087 +4088 +4089 +4090 +4091 +4092 +4093 +4094 +4095 +4096 +4097 +4098 +4099 +4100 +4101 +4102 +4103 +4104 +4105 +4106 +4107 +4108 +4109 +4110 +4111 +4112 +4113 +4114 +4115 +4116 +4117 +4118 +4119 +4120 +4121 +4122 +4123 +4124 +4125 +4126 +4127 +4128 +4129 +4130 +4131 +4132 +4133 +4134 +4135 +4136 +4137 +4138 +4139 +4140 +4141 +4142 +4143 +4144 +4145 +4146 +4147 +4148 +4149 +4150 +4151 +4152 +4153 +4154 +4155 +4156 +4157 +4158 +4159 +4160 +4161 +4162 +4163 +4164 +4165 +4166 +4167 +4168 +4169 +4170 +4171 +4172 +4173 +4174 +4175 +4176 +4177 +4178 +4179 +4180 +4181 +4182 +4183 +4184 +4185 +4186 +4187 +4188 +4189 +4190 +4191 +4192 +4193 +4194 +4195 +4196 +4197 +4198 +4199 +4200 +4201 +4202 +4203 +4204 +4205 +4206 +4207 +4208 +4209 +4210 +4211 +4212 +4213 +4214 +4215 +4216 +4217 +4218 +4219 +4220 +4221 +4222 +4223 +4224 +4225 +4226 +4227 +4228 +4229 +4230 +4231 +4232 +4233 +4234 +4235 +4236 +4237 +4238 +4239 +4240 +4241 +4242 +4243 +4244 +4245 +4246 +4247 +4248 +4249 +4250 +4251 +4252 +4253 +4254 +4255 +4256 +4257 +4258 +4259 +4260 +4261 +4262 +4263 +4264 +4265 +4266 +4267 +4268 +4269 +4270 +4271 +4272 +4273 +4274 +4275 +4276 +4277 +4278 +4279 +4280 +4281 +4282 +4283 +4284 +4285 +4286 +4287 +4288 +4289 +4290 +4291 +4292 +4293 +4294 +4295 +4296 +4297 +4298 +4299 +4300 +4301 +4302 +4303 +4304 +4305 +4306 +4307 +4308 +4309 +4310 +4311 +4312 +4313 +4314 +4315 +4316 +4317 +4318 +4319 +4320 +4321 +4322 +4323 +4324 +4325 +4326 +4327 +4328 +4329 +4330 +4331 +4332 +4333 +4334 +4335 +4336 +4337 +4338 +4339 +4340 +4341 +4342 +4343 +4344 +4345 +4346 +4347 +4348 +4349 +4350 +4351 +4352 +4353 +4354 +4355 +4356 +4357 +4358 +4359 +4360 +4361 +4362 +4363 +4364 +4365 +4366 +4367 +4368 +4369 +4370 +4371 +4372 +4373 +4374 +4375 +4376 +4377 +4378 +4379 +4380 +4381 +4382 +4383 +4384 +4385 +4386 +4387 +4388 +4389 +4390 +4391 +4392 +4393 +4394 +4395 +4396 +4397 +4398 +4399 +4400 +4401 +4402 +4403 +4404 +4405 +4406 +4407 +4408 +4409 +4410 +4411 +4412 +4413 +4414 +4415 +4416 +4417 +4418 +4419 +4420 +4421 +4422 +4423 +4424 +4425 +4426 +4427 +4428 +4429 +4430 +4431 +4432 +4433 +4434 +4435 +4436 +4437 +4438 +4439 +4440 +4441 +4442 +4443 +4444 +4445 +4446 +4447 +4448 +4449 +4450 +4451 +4452 +4453 +4454 +4455 +4456 +4457 +4458 +4459 +4460 +4461 +4462 +4463 +4464 +4465 +4466 +4467 +4468 +4469 +4470 +4471 +4472 +4473 +4474 +4475 +4476 +4477 +4478 +4479 +4480 +4481 +4482 +4483 +4484 +4485 +4486 +4487 +4488 +4489 +4490 +4491 +4492 +4493 +4494 +4495 +4496 +4497 +4498 +4499 +4500 +4501 +4502 +4503 +4504 +4505 +4506 +4507 +4508 +4509 +4510 +4511 +4512 +4513 +4514 +4515 +4516 +4517 +4518 +4519 +4520 +4521 +4522 +4523 +4524 +4525 +4526 +4527 +4528 +4529 +4530 +4531 +4532 +4533 +4534 +4535 +4536 +4537 +4538 +4539 +4540 +4541 +4542 +4543 +4544 +4545 +4546 +4547 +4548 +4549 +4550 +4551 +4552 +4553 +4554 +4555 +4556 +4557 +4558 +4559 +4560 +4561 +4562 +4563 +4564 +4565 +4566 +4567 +4568 +4569 +4570 +4571 +4572 +4573 +4574 +4575 +4576 +4577 +4578 +4579 +4580 +4581 +4582 +4583 +4584 +4585 +4586 +4587 +4588 +4589 +4590 +4591 +4592 +4593 +4594 +4595 +4596 +4597 +4598 +4599 +4600 +4601 +4602 +4603 +4604 +4605 +4606 +4607 +4608 +4609 +4610 +4611 +4612 +4613 +4614 +4615 +4616 +4617 +4618 +4619 +4620 +4621 +4622 +4623 +4624 +4625 +4626 +4627 +4628 +4629 +4630 +4631 +4632 +4633 +4634 +4635 +4636 +4637 +4638 +4639 +4640 +4641 +4642 +4643 +4644 +4645 +4646 +4647 +4648 +4649 +4650 +4651 +4652 +4653 +4654 +4655 +4656 +4657 +4658 +4659 +4660 +4661 +4662 +4663 +4664 +4665 +4666 +4667 +4668 +4669 +4670 +4671 +4672 +4673 +4674 +4675 +4676 +4677 +4678 +4679 +4680 +4681 +4682 +4683 +4684 +4685 +4686 +4687 +4688 +4689 +4690 +4691 +4692 +4693 +4694 +4695 +4696 +4697 +4698 +4699 +4700 +4701 +4702 +4703 +4704 +4705 +4706 +4707 +4708 +4709 +4710 +4711 +4712 +4713 +4714 +4715 +4716 +4717 +4718 +4719 +4720 +4721 +4722 +4723 +4724 +4725 +4726 +4727 +4728 +4729 +4730 +4731 +4732 +4733 +4734 +4735 +4736 +4737 +4738 +4739 +4740 +4741 +4742 +4743 +4744 +4745 +4746 +4747 +4748 +4749 +4750 +4751 +4752 +4753 +4754 +4755 +4756 +4757 +4758 +4759 +4760 +4761 +4762 +4763 +4764 +4765 +4766 +4767 +4768 +4769 +4770 +4771 +4772 +4773 +4774 +4775 +4776 +4777 +4778 +4779 +4780 +4781 +4782 +4783 +4784 +4785 +4786 +4787 +4788 +4789 +4790 +4791 +4792 +4793 +4794 +4795 +4796 +4797 +4798 +4799 +4800 +4801 +4802 +4803 +4804 +4805 +4806 +4807 +4808 +4809 +4810 +4811 +4812 +4813 +4814 +4815 +4816 +4817 +4818 +4819 +4820 +4821 +4822 +4823 +4824 +4825 +4826 +4827 +4828 +4829 +4830 +4831 +4832 +4833 +4834 +4835 +4836 +4837 +4838 +4839 +4840 +4841 +4842 +4843 +4844 +4845 +4846 +4847 +4848 +4849 +4850 +4851 +4852 +4853 +4854 +4855 +4856 +4857 +4858 +4859 +4860 +4861 +4862 +4863 +4864 +4865 +4866 +4867 +4868 +4869 +4870 +4871 +4872 +4873 +4874 +4875 +4876 +4877 +4878 +4879 +4880 +4881 +4882 +4883 +4884 +4885 +4886 +4887 +4888 +4889 +4890 +4891 +4892 +4893 +4894 +4895 +4896 +4897 +4898 +4899 +4900 +4901 +4902 +4903 +4904 +4905 +4906 +4907 +4908 +4909 +4910 +4911 +4912 +4913 +4914 +4915 +4916 +4917 +4918 +4919 +4920 +4921 +4922 +4923 +4924 +4925 +4926 +4927 +4928 +4929 +4930 +4931 +4932 +4933 +4934 +4935 +4936 +4937 +4938 +4939 +4940 +4941 +4942 +4943 +4944 +4945 +4946 +4947 +4948 +4949 +4950 +4951 +4952 +4953 +4954 +4955 +4956 +4957 +4958 +4959 +4960 +4961 +4962 +4963 +4964 +4965 +4966 +4967 +4968 +4969 +4970 +4971 +4972 +4973 +4974 +4975 +4976 +4977 +4978 +4979 +4980 +4981 +4982 +4983 +4984 +4985 +4986 +4987 +4988 +4989 +4990 +4991 +4992 +4993 +4994 +4995 +4996 +4997 +4998 +4999 +5000 +5001 +5002 +5003 +5004 +5005 +5006 +5007 +5008 +5009 +5010 +5011 +5012 +5013 +5014 +5015 +5016 +5017 +5018 +5019 +5020 +5021 +5022 +5023 +5024 +5025 +5026 +5027 +5028 +5029 +5030 +5031 +5032 +5033 +5034 +5035 +5036 +5037 +5038 +5039 +5040 +5041 +5042 +5043 +5044 +5045 +5046 +5047 +5048 +5049 +5050 +5051 +5052 +5053 +5054 +5055 +5056 +5057 +5058 +5059 +5060 +5061 +5062 +5063 +5064 +5065 +5066 +5067 +5068 +5069 +5070 +5071 +5072 +5073 +5074 +5075 +5076 +5077 +5078 +5079 +5080 +5081 +5082 +5083 +5084 +5085 +5086 +5087 +5088 +5089 +5090 +5091 +5092 +5093 +5094 +5095 +5096 +5097 +5098 +5099 +5100 +5101 +5102 +5103 +5104 +5105 +5106 +5107 +5108 +5109 +5110 +5111 +5112 +5113 +5114 +5115 +5116 +5117 +5118 +5119 +5120 +5121 +5122 +5123 +5124 +5125 +5126 +5127 +5128 +5129 +5130 +5131 +5132 +5133 +5134 +5135 +5136 +5137 +5138 +5139 +5140 +5141 +5142 +5143 +5144 +5145 +5146 +5147 +5148 +5149 +5150 +5151 +5152 +5153 +5154 +5155 +5156 +5157 +5158 +5159 +5160 +5161 +5162 +5163 +5164 +5165 +5166 +5167 +5168 +5169 +5170 +5171 +5172 +5173 +5174 +5175 +5176 +5177 +5178 +5179 +5180 +5181 +5182 +5183 +5184 +5185 +5186 +5187 +5188 +5189 +5190 +5191 +5192 +5193 +5194 +5195 +5196 +5197 +5198 +5199 +5200 +5201 +5202 +5203 +5204 +5205 +5206 +5207 +5208 +5209 +5210 +5211 +5212 +5213 +5214 +5215 +5216 +5217 +5218 +5219 +5220 +5221 +5222 +5223 +5224 +5225 +5226 +5227 +5228 +5229 +5230 +5231 +5232 +5233 +5234 +5235 +5236 +5237 +5238 +5239 +5240 +5241 +5242 +5243 +5244 +5245 +5246 +5247 +5248 +5249 +5250 +5251 +5252 +5253 +5254 +5255 +5256 +5257 +5258 +5259 +5260 +5261 +5262 +5263 +5264 +5265 +5266 +5267 +5268 +5269 +5270 +5271 +5272 +5273 +5274 +5275 +5276 +5277 +5278 +5279 +5280 +5281 +5282 +5283 +5284 +5285 +5286 +5287 +5288 +5289 +5290 +5291 +5292 +5293 +5294 +5295 +5296 +5297 +5298 +5299 +5300 +5301 +5302 +5303 +5304 +5305 +5306 +5307 +5308 +5309 +5310 +5311 +5312 +5313 +5314 +5315 +5316 +5317 +5318 +5319 +5320 +5321 +5322 +5323 +5324 +5325 +5326 +5327 +5328 +5329 +5330 +5331 +5332 +5333 +5334 +5335 +5336 +5337 +5338 +5339 +5340 +5341 +5342 +5343 +5344 +5345 +5346 +5347 +5348 +5349 +5350 +5351 +5352 +5353 +5354 +5355 +5356 +5357 +5358 +5359 +5360 +5361 +5362 +5363 +5364 +5365 +5366 +5367 +5368 +5369 +5370 +5371 +5372 +5373 +5374 +5375 +5376 +5377 +5378 +5379 +5380 +5381 +5382 +5383 +5384 +5385 +5386 +5387 +5388 +5389 +5390 +5391 +5392 +5393 +5394 +5395 +5396 +5397 +5398 +5399 +5400 +5401 +5402 +5403 +5404 +5405 +5406 +5407 +5408 +5409 +5410 +5411 +5412 +5413 +5414 +5415 +5416 +5417 +5418 +5419 +5420 +5421 +5422 +5423 +5424 +5425 +5426 +5427 +5428 +5429 +5430 +5431 +5432 +5433 +5434 +5435 +5436 +5437 +5438 +5439 +5440 +5441 +5442 +5443 +5444 +5445 +5446 +5447 +5448 +5449 +5450 +5451 +5452 +5453 +5454 +5455 +5456 +5457 +5458 +5459 +5460 +5461 +5462 +5463 +5464 +5465 +5466 +5467 +5468 +5469 +5470 +5471 +5472 +5473 +5474 +5475 +5476 +5477 +5478 +5479 +5480 +5481 +5482 +5483 +5484 +5485 +5486 +5487 +5488 +5489 +5490 +5491 +5492 +5493 +5494 +5495 +5496 +5497 +5498 +5499 +5500 +5501 +5502 +5503 +5504 +5505 +5506 +5507 +5508 +5509 +5510 +5511 +5512 +5513 +5514 +5515 +5516 +5517 +5518 +5519 +5520 +5521 +5522 +5523 +5524 +5525 +5526 +5527 +5528 +5529 +5530 +5531 +5532 +5533 +5534 +5535 +5536 +5537 +5538 +5539 +5540 +5541 +5542 +5543 +5544 +5545 +5546 +5547 +5548 +5549 +5550 +5551 +5552 +5553 +5554 +5555 +5556 +5557 +5558 +5559 +5560 +5561 +5562 +5563 +5564 +5565 +5566 +5567 +5568 +5569 +5570 +5571 +5572 +5573 +5574 +5575 +5576 +5577 +5578 +5579 +5580 +5581 +5582 +5583 +5584 +5585 +5586 +5587 +5588 +5589 +5590 +5591 +5592 +5593 +5594 +5595 +5596 +5597 +5598 +5599 +5600 +5601 +5602 +5603 +5604 +5605 +5606 +5607 +5608 +5609 +5610 +5611 +5612 +5613 +5614 +5615 +5616 +5617 +5618 +5619 +5620 +5621 +5622 +5623 +5624 +5625 +5626 +5627 +5628 +5629 +5630 +5631 +5632 +5633 +5634 +5635 +5636 +5637 +5638 +5639 +5640 +5641 +5642 +5643 +5644 +5645 +5646 +5647 +5648 +5649 +5650 +5651 +5652 +5653 +5654 +5655 +5656 +5657 +5658 +5659 +5660 +5661 +5662 +5663 +5664 +5665 +5666 +5667 +5668 +5669 +5670 +5671 +5672 +5673 +5674 +5675 +5676 +5677 +5678 +5679 +5680 +5681 +5682 +5683 +5684 +5685 +5686 +5687 +5688 +5689 +5690 +5691 +5692 +5693 +5694 +5695 +5696 +5697 +5698 +5699 +5700 +5701 +5702 +5703 +5704 +5705 +5706 +5707 +5708 +5709 +5710 +5711 +5712 +5713 +5714 +5715 +5716 +5717 +5718 +5719 +5720 +5721 +5722 +5723 +5724 +5725 +5726 +5727 +5728 +5729 +5730 +5731 +5732 +5733 +5734 +5735 +5736 +5737 +5738 +5739 +5740 +5741 +5742 +5743 +5744 +5745 +5746 +5747 +5748 +5749 +5750 +5751 +5752 +5753 +5754 +5755 +5756 +5757 +5758 +5759 +5760 +5761 +5762 +5763 +5764 +5765 +5766 +5767 +5768 +5769 +5770 +5771 +5772 +5773 +5774 +5775 +5776 +5777 +5778 +5779 +5780 +5781 +5782 +5783 +5784 +5785 +5786 +5787 +5788 +5789 +5790 +5791 +5792 +5793 +5794 +5795 +5796 +5797 +5798 +5799 +5800 +5801 +5802 +5803 +5804 +5805 +5806 +5807 +5808 +5809 +5810 +5811 +5812 +5813 +5814 +5815 +5816 +5817 +5818 +5819 +5820 +5821 +5822 +5823 +5824 +5825 +5826 +5827 +5828 +5829 +5830 +5831 +5832 +5833 +5834 +5835 +5836 +5837 +5838 +5839 +5840 +5841 +5842 +5843 +5844 +5845 +5846 +5847 +5848 +5849 +5850 +5851 +5852 +5853 +5854 +5855 +5856 +5857 +5858 +5859 +5860 +5861 +5862 +5863 +5864 +5865 +5866 +5867 +5868 +5869 +5870 +5871 +5872 +5873 +5874 +5875 +5876 +5877 +5878 +5879 +5880 +5881 +5882 +5883 +5884 +5885 +5886 +5887 +5888 +5889 +5890 +5891 +5892 +5893 +5894 +5895 +5896 +5897 +5898 +5899 +5900 +5901 +5902 +5903 +5904 +5905 +5906 +5907 +5908 +5909 +5910 +5911 +5912 +5913 +5914 +5915 +5916 +5917 +5918 +5919 +5920 +5921 +5922 +5923 +5924 +5925 +5926 +5927 +5928 +5929 +5930 +5931 +5932 +5933 +5934 +5935 +5936 +5937 +5938 +5939 +5940 +5941 +5942 +5943 +5944 +5945 +5946 +5947 +5948 +5949 +5950 +5951 +5952 +5953 +5954 +5955 +5956 +5957 +5958 +5959 +5960 +5961 +5962 +5963 +5964 +5965 +5966 +5967 +5968 +5969 +5970 +5971 +5972 +5973 +5974 +5975 +5976 +5977 +5978 +5979 +5980 +5981 +5982 +5983 +5984 +5985 +5986 +5987 +5988 +5989 +5990 +5991 +5992 +5993 +5994 +5995 +5996 +5997 +5998 +5999 +6000 +6001 +6002 +6003 +
+#![allow(clippy::float_cmp)] + +use self::registers::*; +use crate::error::Error; +use crate::microwasm::{BrTarget, Ieee32, Ieee64, SignlessType, Type, Value, F32, F64, I32, I64}; +use crate::module::ModuleContext; +use cranelift_codegen::{binemit, ir}; +use dynasm::dynasm; +use dynasmrt::x64::Assembler; +use dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi, ExecutableBuffer}; +use either::Either; + +use std::{ + any::{Any, TypeId}, + cmp::Ordering, + collections::HashMap, + convert::{TryFrom, TryInto}, + fmt::Display, + iter::{self, FromIterator}, + mem, + ops::RangeInclusive, +}; + +// TODO: Get rid of this! It's a total hack. +mod magic { + use cranelift_codegen::ir; + + /// Compute an `ir::ExternalName` for the `memory.grow` libcall for + /// 32-bit locally-defined memories. + pub fn get_memory32_grow_name() -> ir::ExternalName { + ir::ExternalName::user(1, 0) + } + + /// Compute an `ir::ExternalName` for the `memory.grow` libcall for + /// 32-bit imported memories. + pub fn get_imported_memory32_grow_name() -> ir::ExternalName { + ir::ExternalName::user(1, 1) + } + + /// Compute an `ir::ExternalName` for the `memory.size` libcall for + /// 32-bit locally-defined memories. + pub fn get_memory32_size_name() -> ir::ExternalName { + ir::ExternalName::user(1, 2) + } + + /// Compute an `ir::ExternalName` for the `memory.size` libcall for + /// 32-bit imported memories. + pub fn get_imported_memory32_size_name() -> ir::ExternalName { + ir::ExternalName::user(1, 3) + } +} + +/// Size of a pointer on the target in bytes. +const WORD_SIZE: u32 = 8; + +type RegId = u8; + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum GPR { + Rq(RegId), + Rx(RegId), +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub enum GPRType { + Rq, + Rx, +} + +impl From<SignlessType> for GPRType { + fn from(other: SignlessType) -> GPRType { + match other { + I32 | I64 => GPRType::Rq, + F32 | F64 => GPRType::Rx, + } + } +} + +impl From<SignlessType> for Option<GPRType> { + fn from(other: SignlessType) -> Self { + Some(other.into()) + } +} + +impl GPR { + fn type_(self) -> GPRType { + match self { + GPR::Rq(_) => GPRType::Rq, + GPR::Rx(_) => GPRType::Rx, + } + } + + fn rq(self) -> Option<RegId> { + match self { + GPR::Rq(r) => Some(r), + GPR::Rx(_) => None, + } + } + + fn rx(self) -> Option<RegId> { + match self { + GPR::Rx(r) => Some(r), + GPR::Rq(_) => None, + } + } +} + +pub fn arg_locs(types: impl IntoIterator<Item = SignlessType>) -> Result<Vec<CCLoc>, Error> { + let types = types.into_iter(); + let mut out = Vec::with_capacity(types.size_hint().0); + // TODO: VmCtx is in the first register + let mut int_gpr_iter = INTEGER_ARGS_IN_GPRS.iter(); + let mut float_gpr_iter = FLOAT_ARGS_IN_GPRS.iter(); + let mut stack_idx = 0; + + for ty in types { + match ty { + I32 | I64 => out.push(int_gpr_iter.next().map(|&r| CCLoc::Reg(r)).unwrap_or_else( + || { + let out = CCLoc::Stack(stack_idx); + stack_idx += 1; + out + }, + )), + F32 | F64 => match float_gpr_iter.next() { + None => { + return Err(Error::Microwasm( + "Float args on stack not yet supported".to_string(), + )) + } + Some(val) => out.push(CCLoc::Reg(*val)), + }, + } + } + + Ok(out) +} + +pub fn ret_locs(types: impl IntoIterator<Item = SignlessType>) -> Result<Vec<CCLoc>, Error> { + let types = types.into_iter(); + let mut out = Vec::with_capacity(types.size_hint().0); + // TODO: VmCtx is in the first register + let mut int_gpr_iter = INTEGER_RETURN_GPRS.iter(); + let mut float_gpr_iter = FLOAT_RETURN_GPRS.iter(); + + for ty in types { + match ty { + I32 | I64 => match int_gpr_iter.next() { + None => { + return Err(Error::Microwasm( + "We don't support stack returns yet".to_string(), + )) + } + Some(val) => out.push(CCLoc::Reg(*val)), + }, + F32 | F64 => match float_gpr_iter.next() { + None => { + return Err(Error::Microwasm( + "We don't support stack returns yet".to_string(), + )) + } + Some(val) => out.push(CCLoc::Reg(*val)), + }, + } + } + + Ok(out) +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +struct GPRs { + bits: u16, +} + +impl GPRs { + fn new() -> Self { + Self { bits: 0 } + } +} + +#[allow(dead_code)] +pub mod registers { + use super::{RegId, GPR}; + + pub mod rq { + use super::RegId; + + pub const RAX: RegId = 0; + pub const RCX: RegId = 1; + pub const RDX: RegId = 2; + pub const RBX: RegId = 3; + pub const RSP: RegId = 4; + pub const RBP: RegId = 5; + pub const RSI: RegId = 6; + pub const RDI: RegId = 7; + pub const R8: RegId = 8; + pub const R9: RegId = 9; + pub const R10: RegId = 10; + pub const R11: RegId = 11; + pub const R12: RegId = 12; + pub const R13: RegId = 13; + pub const R14: RegId = 14; + pub const R15: RegId = 15; + } + + pub const RAX: GPR = GPR::Rq(self::rq::RAX); + pub const RCX: GPR = GPR::Rq(self::rq::RCX); + pub const RDX: GPR = GPR::Rq(self::rq::RDX); + pub const RBX: GPR = GPR::Rq(self::rq::RBX); + pub const RSP: GPR = GPR::Rq(self::rq::RSP); + pub const RBP: GPR = GPR::Rq(self::rq::RBP); + pub const RSI: GPR = GPR::Rq(self::rq::RSI); + pub const RDI: GPR = GPR::Rq(self::rq::RDI); + pub const R8: GPR = GPR::Rq(self::rq::R8); + pub const R9: GPR = GPR::Rq(self::rq::R9); + pub const R10: GPR = GPR::Rq(self::rq::R10); + pub const R11: GPR = GPR::Rq(self::rq::R11); + pub const R12: GPR = GPR::Rq(self::rq::R12); + pub const R13: GPR = GPR::Rq(self::rq::R13); + pub const R14: GPR = GPR::Rq(self::rq::R14); + pub const R15: GPR = GPR::Rq(self::rq::R15); + + pub const XMM0: GPR = GPR::Rx(0); + pub const XMM1: GPR = GPR::Rx(1); + pub const XMM2: GPR = GPR::Rx(2); + pub const XMM3: GPR = GPR::Rx(3); + pub const XMM4: GPR = GPR::Rx(4); + pub const XMM5: GPR = GPR::Rx(5); + pub const XMM6: GPR = GPR::Rx(6); + pub const XMM7: GPR = GPR::Rx(7); + pub const XMM8: GPR = GPR::Rx(8); + pub const XMM9: GPR = GPR::Rx(9); + pub const XMM10: GPR = GPR::Rx(10); + pub const XMM11: GPR = GPR::Rx(11); + pub const XMM12: GPR = GPR::Rx(12); + pub const XMM13: GPR = GPR::Rx(13); + pub const XMM14: GPR = GPR::Rx(14); + pub const XMM15: GPR = GPR::Rx(15); + + pub const NUM_GPRS: u8 = 16; +} + +const SIGN_MASK_F64: u64 = 0x8000_0000_0000_0000; +const REST_MASK_F64: u64 = !SIGN_MASK_F64; +const SIGN_MASK_F32: u32 = 0x8000_0000; +const REST_MASK_F32: u32 = !SIGN_MASK_F32; + +impl GPRs { + fn take(&mut self) -> Option<RegId> { + let lz = self.bits.trailing_zeros(); + if lz < 16 { + let gpr = lz as RegId; + self.mark_used(gpr); + Some(gpr) + } else { + None + } + } + + fn mark_used(&mut self, gpr: RegId) { + self.bits &= !(1 << gpr as u16); + } + + fn release(&mut self, gpr: RegId) { + debug_assert!( + !self.is_free(gpr), + "released register {} was already free", + gpr + ); + self.bits |= 1 << gpr; + } + + fn is_free(self, gpr: RegId) -> bool { + (self.bits & (1 << gpr)) != 0 + } +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub struct Registers { + /// Registers at 64 bits and below (al/ah/ax/eax/rax, for example) + scratch_64: (GPRs, [u8; NUM_GPRS as usize]), + /// Registers at 128 bits (xmm0, for example) + scratch_128: (GPRs, [u8; NUM_GPRS as usize]), +} + +impl Default for Registers { + fn default() -> Self { + Self::new() + } +} + +impl Registers { + pub fn new() -> Self { + Self { + scratch_64: (GPRs::new(), [1; NUM_GPRS as _]), + scratch_128: (GPRs::new(), [1; NUM_GPRS as _]), + } + } + + pub fn release_scratch_register(&mut self) -> Result<(), Error> { + // Give ourselves a few scratch registers to work with, for now. + for &scratch in SCRATCH_REGS { + self.release(scratch)?; + } + Ok(()) + } + + fn scratch_counts_mut(&mut self, gpr: GPR) -> (u8, &mut (GPRs, [u8; NUM_GPRS as usize])) { + match gpr { + GPR::Rq(r) => (r, &mut self.scratch_64), + GPR::Rx(r) => (r, &mut self.scratch_128), + } + } + + fn scratch_counts(&self, gpr: GPR) -> (u8, &(GPRs, [u8; NUM_GPRS as usize])) { + match gpr { + GPR::Rq(r) => (r, &self.scratch_64), + GPR::Rx(r) => (r, &self.scratch_128), + } + } + + pub fn mark_used(&mut self, gpr: GPR) { + let (gpr, scratch_counts) = self.scratch_counts_mut(gpr); + scratch_counts.0.mark_used(gpr); + scratch_counts.1[gpr as usize] += 1; + } + + pub fn num_usages(&self, gpr: GPR) -> u8 { + let (gpr, scratch_counts) = self.scratch_counts(gpr); + scratch_counts.1[gpr as usize] + } + + pub fn take(&mut self, ty: impl Into<GPRType>) -> Option<GPR> { + let (mk_gpr, scratch_counts) = match ty.into() { + GPRType::Rq => (GPR::Rq as fn(_) -> _, &mut self.scratch_64), + GPRType::Rx => (GPR::Rx as fn(_) -> _, &mut self.scratch_128), + }; + + let out = scratch_counts.0.take()?; + scratch_counts.1[out as usize] += 1; + Some(mk_gpr(out)) + } + + pub fn release(&mut self, gpr: GPR) -> Result<(), Error> { + let (gpr, scratch_counts) = self.scratch_counts_mut(gpr); + let c = &mut scratch_counts.1[gpr as usize]; + *c = match c.checked_sub(1) { + Some(e) => e, + None => return Err(Error::Microwasm(format!("Double-freed register: {}", gpr))), + }; + if *c == 0 { + scratch_counts.0.release(gpr); + } + Ok(()) + } + + pub fn is_free(&self, gpr: GPR) -> bool { + let (gpr, scratch_counts) = self.scratch_counts(gpr); + scratch_counts.0.is_free(gpr) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct BlockCallingConvention { + pub stack_depth: StackDepth, + pub arguments: Vec<CCLoc>, +} + +impl BlockCallingConvention { + pub fn function_start(args: impl IntoIterator<Item = CCLoc>) -> Self { + BlockCallingConvention { + // We start and return the function with stack depth 1 since we must + // allow space for the saved return address. + stack_depth: StackDepth(1), + arguments: Vec::from_iter(args), + } + } +} + +// TODO: Combine this with `ValueLocation`? +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum CCLoc { + /// Value exists in a register. + Reg(GPR), + /// Value exists on the stack. + Stack(i32), +} + +impl CCLoc { + fn try_from(other: ValueLocation) -> Option<Self> { + match other { + ValueLocation::Reg(reg) => Some(CCLoc::Reg(reg)), + ValueLocation::Stack(offset) => Some(CCLoc::Stack(offset)), + _ => None, + } + } +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum CondCode { + CF0, + CF1, + ZF0, + ZF1, + CF0AndZF0, + CF1OrZF1, + ZF0AndSFEqOF, + ZF1OrSFNeOF, + SFEqOF, + SFNeOF, +} + +mod cc { + use super::CondCode; + + pub const EQUAL: CondCode = CondCode::ZF0; + pub const NOT_EQUAL: CondCode = CondCode::ZF1; + pub const GE_U: CondCode = CondCode::CF0; + pub const LT_U: CondCode = CondCode::CF1; + pub const GT_U: CondCode = CondCode::CF0AndZF0; + pub const LE_U: CondCode = CondCode::CF1OrZF1; + pub const GE_S: CondCode = CondCode::SFEqOF; + pub const LT_S: CondCode = CondCode::SFNeOF; + pub const GT_S: CondCode = CondCode::ZF0AndSFEqOF; + pub const LE_S: CondCode = CondCode::ZF1OrSFNeOF; +} + +impl std::ops::Not for CondCode { + type Output = Self; + + fn not(self) -> Self { + use CondCode::*; + + match self { + CF0 => CF1, + CF1 => CF0, + ZF0 => ZF1, + ZF1 => ZF0, + CF0AndZF0 => CF1OrZF1, + CF1OrZF1 => CF0AndZF0, + ZF0AndSFEqOF => ZF1OrSFNeOF, + ZF1OrSFNeOF => ZF0AndSFEqOF, + SFEqOF => SFNeOF, + SFNeOF => SFEqOF, + } + } +} + +/// Describes location of a value. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ValueLocation { + /// Value exists in a register. + Reg(GPR), + /// Value exists on the stack. Note that this offset is from the rsp as it + /// was when we entered the function. + Stack(i32), + /// Value is a literal + Immediate(Value), + /// Value is a set condition code + Cond(CondCode), +} + +impl From<CCLoc> for ValueLocation { + fn from(other: CCLoc) -> Self { + match other { + CCLoc::Reg(r) => ValueLocation::Reg(r), + CCLoc::Stack(o) => ValueLocation::Stack(o), + } + } +} + +impl ValueLocation { + fn stack(self) -> Option<i32> { + match self { + ValueLocation::Stack(o) => Some(o), + _ => None, + } + } + + fn reg(self) -> Option<GPR> { + match self { + ValueLocation::Reg(r) => Some(r), + _ => None, + } + } + + fn immediate(self) -> Option<Value> { + match self { + ValueLocation::Immediate(i) => Some(i), + _ => None, + } + } + + fn imm_i32(self) -> Option<i32> { + self.immediate().and_then(Value::as_i32) + } + + fn imm_i64(self) -> Option<i64> { + self.immediate().and_then(Value::as_i64) + } + + fn imm_f32(self) -> Option<Ieee32> { + self.immediate().and_then(Value::as_f32) + } + + fn imm_f64(self) -> Option<Ieee64> { + self.immediate().and_then(Value::as_f64) + } +} + +// TODO: This assumes only system-v calling convention. +// In system-v calling convention the first 6 arguments are passed via registers. +// All rest arguments are passed on the stack. +const INTEGER_ARGS_IN_GPRS: &[GPR] = &[RSI, RDX, RCX, R8, R9]; +const INTEGER_RETURN_GPRS: &[GPR] = &[RAX, RDX]; +const FLOAT_ARGS_IN_GPRS: &[GPR] = &[XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7]; +const FLOAT_RETURN_GPRS: &[GPR] = &[XMM0, XMM1]; +// List of scratch registers taken from https://wiki.osdev.org/System_V_ABI +const SCRATCH_REGS: &[GPR] = &[ + RSI, RDX, RCX, R8, R9, RAX, R10, R11, XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7, XMM8, + XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, +]; +const VMCTX: RegId = rq::RDI; + +#[must_use] +#[derive(Debug, Clone)] +pub struct FunctionEnd { + should_generate_epilogue: bool, +} + +pub struct CodeGenSession<'module, M> { + assembler: Assembler, + pub module_context: &'module M, + pub op_offset_map: Vec<(AssemblyOffset, Box<dyn Display + Send + Sync>)>, + labels: Labels, + func_starts: Vec<(Option<AssemblyOffset>, DynamicLabel)>, +} + +impl<'module, M> CodeGenSession<'module, M> { + pub fn new(func_count: u32, module_context: &'module M) -> Self { + let mut assembler = Assembler::new().unwrap(); + let func_starts = iter::repeat_with(|| (None, assembler.new_dynamic_label())) + .take(func_count as usize) + .collect::<Vec<_>>(); + + CodeGenSession { + assembler, + op_offset_map: Default::default(), + labels: Default::default(), + func_starts, + module_context, + } + } + + pub fn new_context<'this>( + &'this mut self, + func_idx: u32, + reloc_sink: &'this mut dyn binemit::RelocSink, + ) -> Context<'this, M> { + { + let func_start = &mut self.func_starts[func_idx as usize]; + + // At this point we know the exact start address of this function. Save it + // and define dynamic label at this location. + func_start.0 = Some(self.assembler.offset()); + self.assembler.dynamic_label(func_start.1); + } + + Context { + asm: &mut self.assembler, + current_function: func_idx, + reloc_sink, + func_starts: &self.func_starts, + labels: &mut self.labels, + block_state: Default::default(), + module_context: self.module_context, + } + } + + fn finalize(&mut self) { + let mut values = self.labels.values_mut().collect::<Vec<_>>(); + values.sort_unstable_by_key(|(_, align, _)| *align); + for (label, align, func) in values { + if let Some(mut func) = func.take() { + dynasm!(self.assembler + ; .align *align as usize + ); + self.assembler.dynamic_label(label.0); + func(&mut self.assembler); + } + } + } + + pub fn into_translated_code_section(mut self) -> Result<TranslatedCodeSection, Error> { + self.finalize(); + let exec_buf = self + .assembler + .finalize() + .map_err(|_asm| Error::Assembler("assembler error".to_owned()))?; + let func_starts = self + .func_starts + .iter() + .map(|(offset, _)| offset.unwrap()) + .collect::<Vec<_>>(); + Ok(TranslatedCodeSection { + exec_buf, + func_starts, + op_offset_map: self.op_offset_map, + // TODO + relocatable_accesses: vec![], + }) + } +} + +#[derive(Debug)] +struct RelocateAddress { + reg: Option<GPR>, + imm: usize, +} + +#[derive(Debug)] +struct RelocateAccess { + position: AssemblyOffset, + dst_reg: GPR, + address: RelocateAddress, +} + +pub struct TranslatedCodeSection { + exec_buf: ExecutableBuffer, + func_starts: Vec<AssemblyOffset>, + #[allow(dead_code)] + relocatable_accesses: Vec<RelocateAccess>, + op_offset_map: Vec<(AssemblyOffset, Box<dyn Display + Send + Sync>)>, +} + +impl TranslatedCodeSection { + pub fn func_start(&self, idx: usize) -> *const u8 { + let offset = self.func_starts[idx]; + self.exec_buf.ptr(offset) + } + + pub fn func_range(&self, idx: usize) -> std::ops::Range<usize> { + let end = self + .func_starts + .get(idx + 1) + .map(|i| i.0) + .unwrap_or_else(|| self.exec_buf.len()); + + self.func_starts[idx].0..end + } + + pub fn funcs<'a>(&'a self) -> impl Iterator<Item = std::ops::Range<usize>> + 'a { + (0..self.func_starts.len()).map(move |i| self.func_range(i)) + } + + pub fn buffer(&self) -> &[u8] { + &*self.exec_buf + } + + pub fn disassemble(&self) { + crate::disassemble::disassemble(&*self.exec_buf, &self.op_offset_map).unwrap(); + } +} + +#[derive(Debug, Default, Clone)] +pub struct BlockState { + pub stack: Stack, + pub depth: StackDepth, + pub regs: Registers, +} + +type Stack = Vec<ValueLocation>; + +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +enum LabelValue { + I32(i32), + I64(i64), +} + +impl From<Value> for LabelValue { + fn from(other: Value) -> LabelValue { + match other { + Value::I32(v) => LabelValue::I32(v), + Value::I64(v) => LabelValue::I64(v), + Value::F32(v) => LabelValue::I32(v.to_bits() as _), + Value::F64(v) => LabelValue::I64(v.to_bits() as _), + } + } +} + +type Labels = HashMap< + (u32, Either<TypeId, (LabelValue, Option<LabelValue>)>), + (Label, u32, Option<Box<dyn FnMut(&mut Assembler)>>), +>; + +pub struct Context<'this, M> { + pub asm: &'this mut Assembler, + reloc_sink: &'this mut dyn binemit::RelocSink, + module_context: &'this M, + current_function: u32, + func_starts: &'this Vec<(Option<AssemblyOffset>, DynamicLabel)>, + /// Each push and pop on the value stack increments or decrements this value by 1 respectively. + pub block_state: BlockState, + labels: &'this mut Labels, +} + +/// Label in code. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub struct Label(DynamicLabel); + +/// Offset from starting value of SP counted in words. +#[derive(Default, Debug, Copy, Clone, PartialEq, Eq)] +pub struct StackDepth(u32); + +impl StackDepth { + pub fn reserve(&mut self, slots: u32) { + self.0 = self.0.checked_add(slots).unwrap(); + } + + pub fn free(&mut self, slots: u32) { + self.0 = self.0.checked_sub(slots).unwrap(); + } +} + +macro_rules! int_div { + ($full_div_s:ident, $full_div_u:ident, $div_u:ident, $div_s:ident, $rem_u:ident, $rem_s:ident, $imm_fn:ident, $signed_ty:ty, $unsigned_ty:ty, $reg_ty:tt, $pointer_ty:tt) => { + // TODO: Fast div using mul for constant divisor? It looks like LLVM doesn't do that for us when + // emitting Wasm. + pub fn $div_u(&mut self) -> Result<(), Error>{ + let divisor = self.pop()?; + let dividend = self.pop()?; + + if let (Some(dividend), Some(divisor)) = (dividend.$imm_fn(), divisor.$imm_fn()) { + if divisor == 0 { + self.trap(); + self.push(ValueLocation::Immediate((0 as $unsigned_ty).into()))?; + } else { + self.push(ValueLocation::Immediate( + <$unsigned_ty>::wrapping_div(dividend as _, divisor as _).into(), + ))?; + } + + return Ok(()) + } + + let (div, rem, saved) = self.$full_div_u(divisor, dividend)?; + + self.free_value(rem)?; + + let div = match div { + ValueLocation::Reg(div) => { + if saved.clone().any(|dst| dst == div) { + let new = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; mov Rq(new.rq().unwrap()), Rq(div.rq().unwrap()) + ); + self.block_state.regs.release(div)?; + ValueLocation::Reg(new) + } else { + ValueLocation::Reg(div) + } + } + _ => div, + }; + + self.cleanup_gprs(saved); + + self.push(div)?; + Ok(()) + } + + // TODO: Fast div using mul for constant divisor? It looks like LLVM doesn't do that for us when + // emitting Wasm. + pub fn $div_s(&mut self) -> Result<(), Error>{ + let divisor = self.pop()?; + let dividend = self.pop()?; + + if let (Some(dividend), Some(divisor)) = (dividend.$imm_fn(), divisor.$imm_fn()) { + if divisor == 0 { + self.trap(); + self.push(ValueLocation::Immediate((0 as $signed_ty).into()))?; + } else { + self.push(ValueLocation::Immediate( + <$signed_ty>::wrapping_div(dividend, divisor).into(), + ))?; + } + + return Ok(()) + } + + let (div, rem, saved) = self.$full_div_s(divisor, dividend)?; + + self.free_value(rem)?; + + let div = match div { + ValueLocation::Reg(div) => { + if saved.clone().any(|dst| dst == div) { + let new = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; mov Rq(new.rq().unwrap()), Rq(div.rq().unwrap()) + ); + self.block_state.regs.release(div)?; + ValueLocation::Reg(new) + } else { + ValueLocation::Reg(div) + } + } + _ => div, + }; + + self.cleanup_gprs(saved); + + self.push(div)?; + Ok(()) + } + + pub fn $rem_u(&mut self) -> Result<(), Error>{ + let divisor = self.pop()?; + let dividend = self.pop()?; + + if let (Some(dividend), Some(divisor)) = (dividend.$imm_fn(), divisor.$imm_fn()) { + if divisor == 0 { + self.trap(); + self.push(ValueLocation::Immediate((0 as $unsigned_ty).into()))?; + } else { + self.push(ValueLocation::Immediate( + (dividend as $unsigned_ty % divisor as $unsigned_ty).into(), + ))?; + } + return Ok(()); + } + + let (div, rem, saved) = self.$full_div_u(divisor, dividend)?; + + self.free_value(div)?; + + let rem = match rem { + ValueLocation::Reg(rem) => { + if saved.clone().any(|dst| dst == rem) { + let new = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; mov Rq(new.rq().unwrap()), Rq(rem.rq().unwrap()) + ); + self.block_state.regs.release(rem)?; + ValueLocation::Reg(new) + } else { + ValueLocation::Reg(rem) + } + } + _ => rem, + }; + + self.cleanup_gprs(saved); + + self.push(rem)?; + Ok(()) + } + + pub fn $rem_s(&mut self) -> Result<(), Error>{ + let mut divisor = self.pop()?; + let dividend = self.pop()?; + + if let (Some(dividend), Some(divisor)) = (dividend.$imm_fn(), divisor.$imm_fn()) { + if divisor == 0 { + self.trap(); + self.push(ValueLocation::Immediate((0 as $signed_ty).into()))?; + } else { + self.push(ValueLocation::Immediate((dividend % divisor).into()))?; + } + return Ok(()); + } + + let is_neg1 = self.create_label(); + + let current_depth = self.block_state.depth.clone(); + + // TODO: This could cause segfaults because of implicit push/pop + let gen_neg1_case = match divisor { + ValueLocation::Immediate(_) => { + if divisor.$imm_fn().unwrap() == -1 { + self.push(ValueLocation::Immediate((-1 as $signed_ty).into()))?; + self.free_value(dividend)?; + return Ok(()); + } + + false + } + ValueLocation::Reg(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut divisor) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp $reg_ty(reg.rq().unwrap()), -1 + ); + // TODO: We could choose `current_depth` as the depth here instead but we currently + // don't for simplicity + self.set_stack_depth(current_depth.clone())?; + dynasm!(self.asm + ; je =>is_neg1.0 + ); + + true + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + dynasm!(self.asm + ; cmp $pointer_ty [rsp + offset], -1 + ); + self.set_stack_depth(current_depth.clone())?; + dynasm!(self.asm + ; je =>is_neg1.0 + ); + + true + } + ValueLocation::Cond(_) => { + // `cc` can never be `-1`, only `0` and `1` + false + } + }; + + let (div, rem, saved) = self.$full_div_s(divisor, dividend)?; + + self.free_value(div)?; + + let rem = match rem { + ValueLocation::Reg(rem) => { + if saved.clone().any(|dst| dst == rem) { + let new = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; mov Rq(new.rq().unwrap()), Rq(rem.rq().unwrap()) + ); + self.block_state.regs.release(rem)?; + ValueLocation::Reg(new) + } else { + ValueLocation::Reg(rem) + } + } + _ => rem, + }; + + self.cleanup_gprs(saved); + + if gen_neg1_case { + let ret = self.create_label(); + self.set_stack_depth(current_depth.clone())?; + dynasm!(self.asm + ; jmp =>ret.0 + ); + self.define_label(is_neg1); + + let dst_ccloc = match CCLoc::try_from(rem) { + None => { + return Err(Error::Microwasm( + "$rem_s Programmer error".to_string(), + )) + } + Some(o) => o, + }; + + self.copy_value( + ValueLocation::Immediate((0 as $signed_ty).into()), + dst_ccloc + )?; + + self.set_stack_depth(current_depth.clone())?; + self.define_label(ret); + } + + self.push(rem)?; + Ok(()) + } + } +} + +macro_rules! unop { + ($name:ident, $instr:ident, $reg_ty:tt, $typ:ty, $const_fallback:expr) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => + ValueLocation::Immediate( + ($const_fallback(imm.as_int().unwrap() as $typ) as $typ).into() + ), + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(Type::for_::<$typ>()).unwrap(); + dynasm!(self.asm + ; $instr $reg_ty(temp.rq().unwrap()), [rsp + offset] + ); + ValueLocation::Reg(temp) + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(Type::for_::<$typ>()).unwrap(); + dynasm!(self.asm + ; $instr $reg_ty(temp.rq().unwrap()), $reg_ty(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + self.push(out_val)?; + Ok(()) + } + } +} + +macro_rules! conversion { + ( + $name:ident, + $instr:ident, + $in_reg_ty:tt, + $in_reg_fn:ident, + $out_reg_ty:tt, + $out_reg_fn:ident, + $in_typ:ty, + $out_typ:ty, + $const_ty_fn:ident, + $const_fallback:expr + ) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => + ValueLocation::Immediate( + $const_fallback(imm.$const_ty_fn().unwrap()).into() + ), + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(Type::for_::<$out_typ>()).unwrap(); + dynasm!(self.asm + ; $instr $out_reg_ty(temp.$out_reg_fn().unwrap()), [rsp + offset] + ); + + ValueLocation::Reg(temp) + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(Type::for_::<$in_typ>(), &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(Type::for_::<$out_typ>()).unwrap(); + + dynasm!(self.asm + ; $instr $out_reg_ty(temp.$out_reg_fn().unwrap()), $in_reg_ty(reg.$in_reg_fn().unwrap()) + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + } +} + +// TODO: Support immediate `count` parameters +macro_rules! shift { + ($name:ident, $reg_ty:tt, $instr:ident, $const_fallback:expr, $ty:expr) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let mut count = self.pop()?; + let mut val = self.pop()?; + + if let Some(imm) = count.immediate() { + if let Some(imm) = imm.as_int() { + if let Ok(imm) = i8::try_from(imm) { + let reg = match self.put_into_temp_register($ty, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; $instr $reg_ty(reg.rq().unwrap()), imm + ); + self.push(ValueLocation::Reg(reg))?; + return Ok(()); + } + } + } + + if val == ValueLocation::Reg(RCX) { + let new = self.take_reg($ty).unwrap(); + self.copy_value(val, CCLoc::Reg(new))?; + self.free_value(val)?; + val = ValueLocation::Reg(new); + } + + // TODO: Maybe allocate `RCX`, write `count` to it and then free `count`. + // Once we've implemented refcounting this will do the right thing + // for free. + let temp_rcx = match count { + ValueLocation::Reg(RCX) => {None} + other => { + let out = if self.block_state.regs.is_free(RCX) { + None + } else { + let new_reg = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; mov Rq(new_reg.rq().unwrap()), rcx + ); + Some(new_reg) + }; + + match other { + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let gpr = match self.put_into_register(I32, &mut count) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + dynasm!(self.asm + ; mov cl, Rb(gpr.rq().unwrap()) + ); + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + dynasm!(self.asm + ; mov cl, [rsp + offset] + ); + } + ValueLocation::Immediate(imm) => { + dynasm!(self.asm + ; mov cl, imm.as_int().unwrap() as i8 + ); + } + } + + out + } + }; + + self.free_value(count)?; + self.block_state.regs.mark_used(RCX); + count = ValueLocation::Reg(RCX); + + let reg = match self.put_into_temp_register($ty, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; $instr $reg_ty(reg.rq().unwrap()), cl + ); + + self.free_value(count)?; + + if let Some(gpr) = temp_rcx { + dynasm!(self.asm + ; mov rcx, Rq(gpr.rq().unwrap()) + ); + self.block_state.regs.release(gpr)?; + } + + self.push(val)?; + Ok(()) + } + } +} + +macro_rules! cmp_i32 { + ($name:ident, $flags:expr, $reverse_flags:expr, $const_fallback:expr) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = if let Some(i) = left.imm_i32() { + match right { + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + dynasm!(self.asm + ; cmp DWORD [rsp + offset], i + ); + ValueLocation::Cond($reverse_flags) + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + dynasm!(self.asm + ; cmp Rd(rreg.rq().unwrap()), i + ); + ValueLocation::Cond($reverse_flags) + } + ValueLocation::Immediate(right) => { + ValueLocation::Immediate( + (if $const_fallback(i, right.as_i32().unwrap()) { + 1i32 + } else { + 0i32 + }).into() + ) + } + } + } else { + let lreg = match self.put_into_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + match right { + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + dynasm!(self.asm + ; cmp Rd(lreg.rq().unwrap()), [rsp + offset] + ); + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp Rd(lreg.rq().unwrap()), Rd(rreg.rq().unwrap()) + ); + } + ValueLocation::Immediate(i) => { + dynasm!(self.asm + ; cmp Rd(lreg.rq().unwrap()), i.as_i32().unwrap() + ); + } + } + + ValueLocation::Cond($flags) + }; + + self.free_value(left)?; + self.free_value(right)?; + + self.push(out)?; + Ok(()) + } + } +} + +macro_rules! cmp_i64 { + ($name:ident, $flags:expr, $reverse_flags:expr, $const_fallback:expr) => { + pub fn $name(&mut self) -> Result<(), Error> { + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = if let Some(i) = left.imm_i64() { + match right { + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + if let Some(i) = i.try_into().ok() { + dynasm!(self.asm + ; cmp QWORD [rsp + offset], i + ); + } else { + let lreg = match self.put_into_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp QWORD [rsp + offset], Rq(lreg.rq().unwrap()) + ); + } + ValueLocation::Cond($reverse_flags) + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + if let Some(i) = i.try_into().ok() { + dynasm!(self.asm + ; cmp Rq(rreg.rq().unwrap()), i + ); + } else { + let lreg = match self.put_into_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp Rq(rreg.rq().unwrap()), Rq(lreg.rq().unwrap()) + ); + } + ValueLocation::Cond($reverse_flags) + } + ValueLocation::Immediate(right) => { + ValueLocation::Immediate( + (if $const_fallback(i, right.as_i64().unwrap()) { + 1i32 + } else { + 0i32 + }).into() + ) + } + } + } else { + let lreg = match self.put_into_register(I64, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + match right { + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + dynasm!(self.asm + ; cmp Rq(lreg.rq().unwrap()), [rsp + offset] + ); + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp Rq(lreg.rq().unwrap()), Rq(rreg.rq().unwrap()) + ); + } + ValueLocation::Immediate(i) => { + let i = i.as_i64().unwrap(); + if let Some(i) = i.try_into().ok() { + dynasm!(self.asm + ; cmp Rq(lreg.rq().unwrap()), i + ); + } else { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; cmp Rq(lreg.rq().unwrap()), Rq(rreg.rq().unwrap()) + ); + } + } + } + + ValueLocation::Cond($flags) + }; + + self.free_value(left)?; + self.free_value(right)?; + self.push(out)?; + Ok(()) + } + } +} + +macro_rules! cmp_f32 { + ($name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => { + cmp_float!( + comiss, + f32, + imm_f32, + $name, + $reverse_name, + $instr, + $const_fallback + ); + }; +} + +macro_rules! eq_float { + ($name:ident, $instr:ident, $imm_fn:ident, $const_fallback:expr) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let right = self.pop()?; + let left = self.pop()?; + + if let Some(right) = right.immediate() { + if let Some(left) = left.immediate() { + self.push(ValueLocation::Immediate( + if $const_fallback(left.$imm_fn().unwrap(), right.$imm_fn().unwrap()) { + 1u32 + } else { + 0 + }.into() + ))?; + return Ok(()); + } + } + + let (mut left, mut right) = match left { + ValueLocation::Reg(r) if self.block_state.regs.num_usages(r) <= 1 => (left, right), + _ => (right, left) + }; + + let lreg = match self.put_into_temp_register(GPRType::Rx, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let rreg = match self.put_into_register(GPRType::Rx, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let out = self.take_reg(I32).unwrap(); + + dynasm!(self.asm + ; $instr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; movd Rd(out.rq().unwrap()), Rx(lreg.rx().unwrap()) + ; and Rd(out.rq().unwrap()), 1 + ); + + self.push(ValueLocation::Reg(out))?; + self.free_value(left)?; + self.free_value(right)?; + Ok(()) + } + + } +} + +macro_rules! minmax_float { + ( + $name:ident, + $instr:ident, + $cmpinstr:ident, + $addinstr:ident, + $combineinstr:ident, + $imm_fn:ident, + $const_fallback:expr + ) => { + pub fn $name(&mut self) -> Result<(), Error>{ + let right = self.pop()?; + let left = self.pop()?; + + if let Some(right) = right.immediate() { + if let Some(left) = left.immediate() { + self.push(ValueLocation::Immediate( + $const_fallback(left.$imm_fn().unwrap(), right.$imm_fn().unwrap()).into() + ))?; + return Ok(()); + } + } + + let (mut left, mut right) = match left { + ValueLocation::Reg(r) if self.block_state.regs.num_usages(r) <= 1 => (left, right), + _ => (right, left) + }; + + let lreg = match self.put_into_temp_register(GPRType::Rx, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let rreg = match self.put_into_register(GPRType::Rx, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; $cmpinstr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; je >equal + ; $instr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; jmp >ret + ; equal: + ; jnp >equal_but_not_parity + ; $addinstr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; jmp >ret + ; equal_but_not_parity: + ; $combineinstr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; ret: + ); + + self.push(left)?; + self.free_value(right)?; + Ok(()) + } + + } +} + +macro_rules! cmp_f64 { + ($name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => { + cmp_float!( + comisd, + f64, + imm_f64, + $name, + $reverse_name, + $instr, + $const_fallback + ); + }; +} + +macro_rules! cmp_float { + (@helper $cmp_instr:ident, $ty:ty, $imm_fn:ident, $self:expr, $left:expr, $right:expr, $instr:ident, $const_fallback:expr) => {{ + let (left, right, this) = ($left, $right, $self); + if let (Some(left), Some(right)) = (left.$imm_fn(), right.$imm_fn()) { + if $const_fallback(<$ty>::from_bits(left.to_bits()), <$ty>::from_bits(right.to_bits())) { + ValueLocation::Immediate(1i32.into()) + } else { + ValueLocation::Immediate(0i32.into()) + } + } else { + let lreg = match this.put_into_register(GPRType::Rx, left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let result = this.take_reg(I32).unwrap(); + + match right { + ValueLocation::Stack(offset) => { + let offset = this.adjusted_offset(*offset); + + dynasm!(this.asm + ; xor Rq(result.rq().unwrap()), Rq(result.rq().unwrap()) + ; $cmp_instr Rx(lreg.rx().unwrap()), [rsp + offset] + ; $instr Rb(result.rq().unwrap()) + ); + } + right => { + let rreg = match this.put_into_register(GPRType::Rx, right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(this.asm + ; xor Rq(result.rq().unwrap()), Rq(result.rq().unwrap()) + ; $cmp_instr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ; $instr Rb(result.rq().unwrap()) + ); + } + } + + ValueLocation::Reg(result) + } + }}; + ($cmp_instr:ident, $ty:ty, $imm_fn:ident, $name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => { + pub fn $name(&mut self) -> Result<(), Error> { + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = cmp_float!(@helper + $cmp_instr, + $ty, + $imm_fn, + &mut *self, + &mut left, + &mut right, + $instr, + $const_fallback + ); + + self.free_value(left)?; + self.free_value(right)?; + + self.push(out)?; + Ok(()) + } + + pub fn $reverse_name(&mut self) -> Result<(), Error> { + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = cmp_float!(@helper + $cmp_instr, + $ty, + $imm_fn, + &mut *self, + &mut right, + &mut left, + $instr, + $const_fallback + ); + + self.free_value(left)?; + self.free_value(right)?; + + self.push(out)?; + Ok(()) + } + }; +} + +macro_rules! binop_i32 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + binop!( + $name, + $instr, + $const_fallback, + Rd, + rq, + I32, + imm_i32, + |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm + ; $instr Rd(op1.rq().unwrap()), i + ) + ); + }; +} + +macro_rules! commutative_binop_i32 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + commutative_binop!( + $name, + $instr, + $const_fallback, + Rd, + rq, + I32, + imm_i32, + |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm + ; $instr Rd(op1.rq().unwrap()), i + ) + ); + }; +} + +macro_rules! binop_i64 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + binop!( + $name, + $instr, + $const_fallback, + Rq, + rq, + I64, + imm_i64, + |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm + ; $instr Rq(op1.rq().unwrap()), i + ) + ); + }; +} + +macro_rules! commutative_binop_i64 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + commutative_binop!( + $name, + $instr, + $const_fallback, + Rq, + rq, + I64, + imm_i64, + |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm + ; $instr Rq(op1.rq().unwrap()), i + ) + ); + }; +} + +macro_rules! binop_f32 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + binop!( + $name, + $instr, + |a: Ieee32, b: Ieee32| Ieee32::from_bits( + $const_fallback(f32::from_bits(a.to_bits()), f32::from_bits(b.to_bits())).to_bits() + ), + Rx, + rx, + F32, + imm_f32, + |_, _, _: i32| unreachable!() + ); + }; +} + +macro_rules! commutative_binop_f32 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + commutative_binop!( + $name, + $instr, + |a: Ieee32, b: Ieee32| Ieee32::from_bits( + $const_fallback(f32::from_bits(a.to_bits()), f32::from_bits(b.to_bits())).to_bits() + ), + Rx, + rx, + F32, + imm_f32, + |_, _, _: i32| unreachable!() + ); + }; +} + +macro_rules! binop_f64 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + binop!( + $name, + $instr, + |a: Ieee64, b: Ieee64| Ieee64::from_bits( + $const_fallback(f64::from_bits(a.to_bits()), f64::from_bits(b.to_bits())).to_bits() + ), + Rx, + rx, + F64, + imm_f64, + |_, _, _: i32| unreachable!() + ); + }; +} + +macro_rules! commutative_binop_f64 { + ($name:ident, $instr:ident, $const_fallback:expr) => { + commutative_binop!( + $name, + $instr, + |a: Ieee64, b: Ieee64| Ieee64::from_bits( + $const_fallback(f64::from_bits(a.to_bits()), f64::from_bits(b.to_bits())).to_bits() + ), + Rx, + rx, + F64, + imm_f64, + |_, _, _: i32| unreachable!() + ); + }; +} +macro_rules! commutative_binop { + ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:tt, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr) => { + binop!( + $name, + $instr, + $const_fallback, + $reg_ty, + $reg_fn, + $ty, + $imm_fn, + $direct_imm, + |op1: ValueLocation, op0: ValueLocation| match op1 { + ValueLocation::Reg(_) => (op1, op0), + _ => { + if op0.immediate().is_some() { + (op1, op0) + } else { + (op0, op1) + } + } + } + ); + }; +} + +macro_rules! binop { + ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:tt, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr) => { + binop!($name, $instr, $const_fallback, $reg_ty, $reg_fn, $ty, $imm_fn, $direct_imm, |a, b| (a, b)); + }; + ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:tt, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr, $map_op:expr) => { + pub fn $name(&mut self) -> Result<(), Error> { + let right = self.pop()?; + let left = self.pop()?; + + if let Some(i1) = left.$imm_fn() { + if let Some(i0) = right.$imm_fn() { + self.block_state.stack.push(ValueLocation::Immediate($const_fallback(i1, i0).into())); + return Ok(()); + } + } + + let (mut left, mut right) = $map_op(left, right); + let lreg = match self.put_into_temp_register($ty, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + match right { + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + // This handles the case where we (for example) have a float in an `Rq` reg + let right_reg = match self.put_into_register($ty, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; $instr $reg_ty(lreg.$reg_fn().unwrap()), $reg_ty(right_reg.$reg_fn().unwrap()) + ); + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + dynasm!(self.asm + ; $instr $reg_ty(lreg.$reg_fn().unwrap()), [rsp + offset] + ); + } + ValueLocation::Immediate(i) => { + if let Some(i) = i.as_int().and_then(|i| i.try_into().ok()) { + $direct_imm(&mut *self, lreg, i); + } else { + let scratch = self.take_reg($ty).unwrap(); + self.immediate_to_reg(scratch, i); + + dynasm!(self.asm + ; $instr $reg_ty(lreg.$reg_fn().unwrap()), $reg_ty(scratch.$reg_fn().unwrap()) + ); + + self.block_state.regs.release(scratch)?; + } + } + } + + self.free_value(right)?; + self.push(left)?; + Ok(()) + } + } +} + +macro_rules! load { + (@inner $name:ident, $rtype:expr, $reg_ty:tt, $emit_fn:expr) => { + pub fn $name(&mut self, offset: u32) -> Result<(), Error> { + fn load_to_reg<_M: ModuleContext>( + ctx: &mut Context<_M>, + dst: GPR, + (offset, runtime_offset): (i32, Result<i32, GPR>) + ) -> Result<(), Error> { + let mem_index = 0; + let reg_offset = ctx.module_context + .defined_memory_index(mem_index) + .map(|index| ( + None, + ctx.module_context.vmctx_vmmemory_definition(index) as i32 + )); + let (reg, mem_offset) = reg_offset.unwrap_or_else(|| { + let reg = ctx.take_reg(I64).unwrap(); + + dynasm!(ctx.asm + ; mov Rq(reg.rq().unwrap()), [ + Rq(VMCTX) + ctx.module_context.vmctx_vmmemory_import_from(mem_index) as i32 + ] + ); + + (Some(reg), 0) + }); + + let vmctx = GPR::Rq(VMCTX); + + if ctx.module_context.emit_memory_bounds_check() { + let trap_label = ctx.trap_label(); + let addr_reg = match runtime_offset { + Ok(imm) => { + let addr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rq(addr_reg.rq().unwrap()), QWORD imm as i64 + offset as i64 + ); + addr_reg + } + Err(gpr) => { + if offset == 0 { + match ctx.clone_to_register(I32, ValueLocation::Reg(gpr)) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + } + + } else if offset > 0 { + let addr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; lea Rq(addr_reg.rq().unwrap()), [Rq(gpr.rq().unwrap()) + offset] + ); + addr_reg + } else { + let addr_reg = ctx.take_reg(I64).unwrap(); + let offset_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rd(offset_reg.rq().unwrap()), offset + ; mov Rq(addr_reg.rq().unwrap()), Rq(gpr.rq().unwrap()) + ; add Rq(addr_reg.rq().unwrap()), Rq(offset_reg.rq().unwrap()) + ); + ctx.block_state.regs.release(offset_reg)?; + addr_reg + } + } + }; + dynasm!(ctx.asm + ; cmp [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + mem_offset + + ctx.module_context.vmmemory_definition_current_length() as i32 + ], Rq(addr_reg.rq().unwrap()) + ; jna =>trap_label.0 + ); + ctx.block_state.regs.release(addr_reg)?; + } + + let mem_ptr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rq(mem_ptr_reg.rq().unwrap()), [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + mem_offset + + ctx.module_context.vmmemory_definition_base() as i32 + ] + ); + if let Some(reg) = reg { + ctx.block_state.regs.release(reg)?; + } + $emit_fn(ctx, dst, mem_ptr_reg, runtime_offset, offset)?; + ctx.block_state.regs.release(mem_ptr_reg)?; + Ok(()) + } + + let base = self.pop()?; + + let temp = self.take_reg($rtype).unwrap(); + + match base { + ValueLocation::Immediate(i) => { + load_to_reg(self, temp, (offset as _, Ok(i.as_i32().unwrap())))?; + } + mut base => { + let gpr = match self.put_into_register(I32, &mut base) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + load_to_reg(self, temp, (offset as _, Err(gpr)))?; + self.free_value(base)?; + } + } + + self.push(ValueLocation::Reg(temp))?; + Ok(()) + } + }; + ($name:ident, $rtype:expr, $reg_ty:tt, NONE, $rq_instr:ident, $ty:ident) => { + load!(@inner + $name, + $rtype, + $reg_ty, + |ctx: &mut Context<_>, dst: GPR, mem_ptr_reg: GPR, runtime_offset: Result<i32, GPR>, offset: i32| -> Result<(), Error> { + match runtime_offset { + Ok(imm) => { + dynasm!(ctx.asm + ; $rq_instr $reg_ty(dst.rq().unwrap()), $ty [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm] + ); + Ok(()) + } + Err(offset_reg) => { + dynasm!(ctx.asm + ; $rq_instr $reg_ty(dst.rq().unwrap()), $ty [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset] + ); + Ok(()) + } + } + } + ); + }; + ($name:ident, $rtype:expr, $reg_ty:tt, $xmm_instr:ident, $rq_instr:ident, $ty:ident) => { + load!(@inner + $name, + $rtype, + $reg_ty, + |ctx: &mut Context<_>, dst: GPR, mem_ptr_reg: GPR, runtime_offset: Result<i32, GPR>, offset: i32| -> Result<(), Error> { + match (dst, runtime_offset) { + (GPR::Rq(r), Ok(imm)) => { + dynasm!(ctx.asm + ; $rq_instr $reg_ty(r), $ty [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm] + ); + Ok(()) + } + (GPR::Rx(r), Ok(imm)) => { + if let Some(combined) = offset.checked_add(imm) { + dynasm!(ctx.asm + ; $xmm_instr Rx(r), $ty [Rq(mem_ptr_reg.rq().unwrap()) + combined] + ); + Ok(()) + } else { + let offset_reg = ctx.take_reg(GPRType::Rq).unwrap(); + dynasm!(ctx.asm + ; mov Rq(offset_reg.rq().unwrap()), offset + ; $xmm_instr Rx(r), $ty [ + Rq(mem_ptr_reg.rq().unwrap()) + + Rq(offset_reg.rq().unwrap()) + + imm + ] + ); + ctx.block_state.regs.release(offset_reg)?; + Ok(()) + } + } + (GPR::Rq(r), Err(offset_reg)) => { + dynasm!(ctx.asm + ; $rq_instr $reg_ty(r), $ty [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset] + ); + Ok(()) + } + (GPR::Rx(r), Err(offset_reg)) => { + dynasm!(ctx.asm + ; $xmm_instr Rx(r), $ty [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset] + ); + Ok(()) + } + } + } + ); + }; +} + +macro_rules! store { + (@inner $name:ident, $int_reg_ty:tt, $match_offset:expr, $size:ident) => { + pub fn $name(&mut self, offset: u32) -> Result<(), Error>{ + fn store_from_reg<_M: ModuleContext>( + ctx: &mut Context<_M>, + src: GPR, + (offset, runtime_offset): (i32, Result<i32, GPR>) + ) -> Result<(), Error> { + let mem_index = 0; + let reg_offset = ctx.module_context + .defined_memory_index(mem_index) + .map(|index| ( + None, + ctx.module_context.vmctx_vmmemory_definition(index) as i32 + )); + let (reg, mem_offset) = reg_offset.unwrap_or_else(|| { + let reg = ctx.take_reg(I64).unwrap(); + + dynasm!(ctx.asm + ; mov Rq(reg.rq().unwrap()), [ + Rq(VMCTX) + ctx.module_context.vmctx_vmmemory_import_from(mem_index) as i32 + ] + ); + + (Some(reg), 0) + }); + + let vmctx = GPR::Rq(VMCTX); + + if ctx.module_context.emit_memory_bounds_check() { + let trap_label = ctx.trap_label(); + let addr_reg = match runtime_offset { + Ok(imm) => { + let addr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rq(addr_reg.rq().unwrap()), QWORD imm as i64 + offset as i64 + ); + addr_reg + } + Err(gpr) => { + if offset == 0 { + match ctx.clone_to_register(I32, ValueLocation::Reg(gpr)) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + } + + } else if offset > 0 { + let addr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; lea Rq(addr_reg.rq().unwrap()), [Rq(gpr.rq().unwrap()) + offset] + ); + addr_reg + } else { + let addr_reg = ctx.take_reg(I64).unwrap(); + let offset_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rd(offset_reg.rq().unwrap()), offset + ; mov Rq(addr_reg.rq().unwrap()), Rq(gpr.rq().unwrap()) + ; add Rq(addr_reg.rq().unwrap()), Rq(offset_reg.rq().unwrap()) + ); + ctx.block_state.regs.release(offset_reg)?; + addr_reg + } + } + }; + dynasm!(ctx.asm + ; cmp Rq(addr_reg.rq().unwrap()), [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + mem_offset + + ctx.module_context.vmmemory_definition_current_length() as i32 + ] + ; jae =>trap_label.0 + ); + ctx.block_state.regs.release(addr_reg)?; + } + + let mem_ptr_reg = ctx.take_reg(I64).unwrap(); + dynasm!(ctx.asm + ; mov Rq(mem_ptr_reg.rq().unwrap()), [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + mem_offset + + ctx.module_context.vmmemory_definition_base() as i32 + ] + ); + if let Some(reg) = reg { + ctx.block_state.regs.release(reg)?; + } + let src = $match_offset(ctx, mem_ptr_reg, runtime_offset, offset, src)?; + ctx.block_state.regs.release(mem_ptr_reg)?; + ctx.block_state.regs.release(src)?; + Ok(()) + } + + if !(offset <= i32::max_value() as u32) { + return Err(Error::Microwasm(format!("store: offset value too big {}", offset))) + } + + let mut src = self.pop()?; + let base = self.pop()?; + + // `store_from_reg` frees `src` + // TODO: Would it be better to free it outside `store_from_reg`? + let src_reg = match self.put_into_register(None, &mut src) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + + match base { + ValueLocation::Immediate(i) => { + store_from_reg(self, src_reg, (offset as i32, Ok(i.as_i32().unwrap())))? + } + mut base => { + let gpr = match self.put_into_register(I32, &mut base) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + store_from_reg(self, src_reg, (offset as i32, Err(gpr)))?; + self.free_value(base)?; + } + } + Ok(()) + } + }; + ($name:ident, $int_reg_ty:tt, NONE, $size:ident) => { + store!(@inner + $name, + $int_reg_ty, + |ctx: &mut Context<_>, mem_ptr_reg: GPR, runtime_offset: Result<i32, GPR>, offset: i32, src| -> Result<GPR, Error> { + let src_reg = match ctx.put_into_temp_register(GPRType::Rq, &mut ValueLocation::Reg(src)) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + match runtime_offset { + Ok(imm) => { + dynasm!(ctx.asm + ; mov [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm], $int_reg_ty(src_reg.rq().unwrap()) + ); + } + Err(offset_reg) => { + dynasm!(ctx.asm + ; mov [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset], $int_reg_ty(src_reg.rq().unwrap()) + ); + } + } + + Ok(src_reg) + }, + $size + ); + }; + ($name:ident, $int_reg_ty:tt, $xmm_instr:ident, $size:ident) => { + store!(@inner + $name, + $int_reg_ty, + |ctx: &mut Context<_>, mem_ptr_reg: GPR, runtime_offset: Result<i32, GPR>, offset: i32, src| -> Result<GPR, Error> { + match (runtime_offset, src) { + (Ok(imm), GPR::Rq(r)) => { + dynasm!(ctx.asm + ; mov [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm], $int_reg_ty(r) + ); + } + (Ok(imm), GPR::Rx(r)) => { + dynasm!(ctx.asm + ; $xmm_instr [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm], Rx(r) + ); + } + (Err(offset_reg), GPR::Rq(r)) => { + dynasm!(ctx.asm + ; mov [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset], $int_reg_ty(r) + ); + } + (Err(offset_reg), GPR::Rx(r)) => { + dynasm!(ctx.asm + ; $xmm_instr [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset], Rx(r) + ); + } + } + + Ok(src) + }, + $size + ); + }; +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VirtualCallingConvention { + pub stack: Stack, + pub depth: StackDepth, +} + +impl<'this, M: ModuleContext> Context<'this, M> { + fn free_reg(&mut self, type_: GPRType) -> Result<bool, Error> { + let pos = if let Some(pos) = self + .block_state + .stack + .iter() + .position(|r| r.reg().map(|reg| reg.type_() == type_).unwrap_or(false)) + { + pos + } else { + return Ok(false); + }; + + let old_loc = self.block_state.stack[pos]; + let new_loc = self.push_physical(old_loc)?; + self.block_state.stack[pos] = new_loc; + + let reg = old_loc.reg().unwrap(); + + for elem in &mut self.block_state.stack[pos + 1..] { + if *elem == old_loc { + *elem = new_loc; + self.block_state.regs.release(reg)?; + } + } + + Ok(true) + } + + fn take_reg(&mut self, r: impl Into<GPRType>) -> Option<GPR> { + let r = r.into(); + loop { + if let Some(gpr) = self.block_state.regs.take(r) { + break Some(gpr); + } + + if self.free_reg(r) == Ok(false) { + break None; + } + } + } + + pub fn virtual_calling_convention(&self) -> VirtualCallingConvention { + VirtualCallingConvention { + stack: self.block_state.stack.clone(), + depth: self.block_state.depth, + } + } + + /// Create a new undefined label. + pub fn create_label(&mut self) -> Label { + Label(self.asm.new_dynamic_label()) + } + + pub fn define_host_fn(&mut self, host_fn: *const u8) { + dynasm!(self.asm + ; mov rax, QWORD host_fn as i64 + ; call rax + ; ret + ); + } + + fn adjusted_offset(&self, offset: i32) -> i32 { + (self.block_state.depth.0 as i32 + offset) * WORD_SIZE as i32 + } + + cmp_i32!(i32_eq, cc::EQUAL, cc::EQUAL, |a, b| a == b); + cmp_i32!(i32_neq, cc::NOT_EQUAL, cc::NOT_EQUAL, |a, b| a != b); + // `dynasm-rs` inexplicably doesn't support setb but `setnae` (and `setc`) are synonymous + cmp_i32!(i32_lt_u, cc::LT_U, cc::GT_U, |a, b| (a as u32) < (b as u32)); + cmp_i32!(i32_le_u, cc::LE_U, cc::GE_U, |a, b| (a as u32) + <= (b as u32)); + cmp_i32!(i32_gt_u, cc::GT_U, cc::LT_U, |a, b| (a as u32) > (b as u32)); + cmp_i32!(i32_ge_u, cc::GE_U, cc::LE_U, |a, b| (a as u32) + >= (b as u32)); + cmp_i32!(i32_lt_s, cc::LT_S, cc::GT_S, |a, b| a < b); + cmp_i32!(i32_le_s, cc::LE_S, cc::GE_S, |a, b| a <= b); + cmp_i32!(i32_gt_s, cc::GT_S, cc::LT_S, |a, b| a > b); + cmp_i32!(i32_ge_s, cc::GE_S, cc::LE_S, |a, b| a >= b); + + cmp_i64!(i64_eq, cc::EQUAL, cc::EQUAL, |a, b| a == b); + cmp_i64!(i64_neq, cc::NOT_EQUAL, cc::NOT_EQUAL, |a, b| a != b); + // `dynasm-rs` inexplicably doesn't support setb but `setnae` (and `setc`) are synonymous + cmp_i64!(i64_lt_u, cc::LT_U, cc::GT_U, |a, b| (a as u64) < (b as u64)); + cmp_i64!(i64_le_u, cc::LE_U, cc::GE_U, |a, b| (a as u64) + <= (b as u64)); + cmp_i64!(i64_gt_u, cc::GT_U, cc::LT_U, |a, b| (a as u64) > (b as u64)); + cmp_i64!(i64_ge_u, cc::GE_U, cc::LE_U, |a, b| (a as u64) + >= (b as u64)); + cmp_i64!(i64_lt_s, cc::LT_S, cc::GT_S, |a, b| a < b); + cmp_i64!(i64_le_s, cc::LE_S, cc::GE_S, |a, b| a <= b); + cmp_i64!(i64_gt_s, cc::GT_S, cc::LT_S, |a, b| a > b); + cmp_i64!(i64_ge_s, cc::GE_S, cc::LE_S, |a, b| a >= b); + + cmp_f32!(f32_gt, f32_lt, seta, |a, b| a > b); + cmp_f32!(f32_ge, f32_le, setnc, |a, b| a >= b); + eq_float!( + f32_eq, + cmpeqss, + as_f32, + |a: Ieee32, b: Ieee32| f32::from_bits(a.to_bits()) == f32::from_bits(b.to_bits()) + ); + eq_float!( + f32_ne, + cmpneqss, + as_f32, + |a: Ieee32, b: Ieee32| f32::from_bits(a.to_bits()) != f32::from_bits(b.to_bits()) + ); + + cmp_f64!(f64_gt, f64_lt, seta, |a, b| a > b); + cmp_f64!(f64_ge, f64_le, setnc, |a, b| a >= b); + eq_float!( + f64_eq, + cmpeqsd, + as_f64, + |a: Ieee64, b: Ieee64| f64::from_bits(a.to_bits()) == f64::from_bits(b.to_bits()) + ); + eq_float!( + f64_ne, + cmpneqsd, + as_f64, + |a: Ieee64, b: Ieee64| f64::from_bits(a.to_bits()) != f64::from_bits(b.to_bits()) + ); + + // TODO: Should we do this logic in `eq` and just have this delegate to `eq`? + // That would mean that `eqz` and `eq` with a const 0 argument don't + // result in different code. It would also allow us to generate better + // code for `neq` and `gt_u` with const 0 operand + pub fn i32_eqz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + if let ValueLocation::Immediate(Value::I32(i)) = val { + self.push(ValueLocation::Immediate( + (if i == 0 { 1i32 } else { 0 }).into(), + ))?; + return Ok(()); + } + + if let ValueLocation::Cond(loc) = val { + self.push(ValueLocation::Cond(!loc))?; + return Ok(()); + } + + let reg = match self.put_into_register(I32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let out = self.take_reg(I32).unwrap(); + + dynasm!(self.asm + ; xor Rd(out.rq().unwrap()), Rd(out.rq().unwrap()) + ; test Rd(reg.rq().unwrap()), Rd(reg.rq().unwrap()) + ; setz Rb(out.rq().unwrap()) + ); + + self.free_value(val)?; + + self.push(ValueLocation::Reg(out))?; + Ok(()) + } + + pub fn i64_eqz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + if let ValueLocation::Immediate(Value::I64(i)) = val { + self.push(ValueLocation::Immediate( + (if i == 0 { 1i32 } else { 0 }).into(), + ))?; + return Ok(()); + } + + if let ValueLocation::Cond(loc) = val { + self.push(ValueLocation::Cond(!loc))?; + return Ok(()); + } + + let reg = match self.put_into_register(I64, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let out = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; xor Rd(out.rq().unwrap()), Rd(out.rq().unwrap()) + ; test Rq(reg.rq().unwrap()), Rq(reg.rq().unwrap()) + ; setz Rb(out.rq().unwrap()) + ); + + self.free_value(val)?; + + self.push(ValueLocation::Reg(out))?; + Ok(()) + } + + fn br_on_cond_code(&mut self, label: Label, cond: CondCode) { + match cond { + cc::EQUAL => dynasm!(self.asm + ; je =>label.0 + ), + cc::NOT_EQUAL => dynasm!(self.asm + ; jne =>label.0 + ), + cc::GT_U => dynasm!(self.asm + ; ja =>label.0 + ), + cc::GE_U => dynasm!(self.asm + ; jae =>label.0 + ), + cc::LT_U => dynasm!(self.asm + ; jb =>label.0 + ), + cc::LE_U => dynasm!(self.asm + ; jbe =>label.0 + ), + cc::GT_S => dynasm!(self.asm + ; jg =>label.0 + ), + cc::GE_S => dynasm!(self.asm + ; jge =>label.0 + ), + cc::LT_S => dynasm!(self.asm + ; jl =>label.0 + ), + cc::LE_S => dynasm!(self.asm + ; jle =>label.0 + ), + } + } + + /// Pops i32 predicate and branches to the specified label + /// if the predicate is equal to zero. + pub fn br_if_false( + &mut self, + target: impl Into<BrTarget<Label>>, + pass_args: impl FnOnce(&mut Self) -> Result<(), Error>, + ) -> Result<(), Error> { + let mut val = self.pop()?; + let label = target + .into() + .label() + .copied() + .unwrap_or_else(|| self.ret_label()); + + let cond = match val { + ValueLocation::Cond(cc) => !cc, + _ => { + let predicate = match self.put_into_register(I32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; test Rd(predicate.rq().unwrap()), Rd(predicate.rq().unwrap()) + ); + + CondCode::ZF0 + } + }; + + self.free_value(val)?; + + pass_args(self)?; + + self.br_on_cond_code(label, cond); + Ok(()) + } + + /// Pops i32 predicate and branches to the specified label + /// if the predicate is not equal to zero. + pub fn br_if_true( + &mut self, + target: impl Into<BrTarget<Label>>, + pass_args: impl FnOnce(&mut Self) -> Result<(), Error>, + ) -> Result<(), Error> { + let mut val = self.pop()?; + let label = target + .into() + .label() + .copied() + .unwrap_or_else(|| self.ret_label()); + + let cond = match val { + ValueLocation::Cond(cc) => cc, + _ => { + let predicate = match self.put_into_register(I32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; test Rd(predicate.rq().unwrap()), Rd(predicate.rq().unwrap()) + ); + + CondCode::ZF1 + } + }; + + self.free_value(val)?; + + pass_args(self)?; + + self.br_on_cond_code(label, cond); + Ok(()) + } + + /// Branch unconditionally to the specified label. + pub fn br(&mut self, label: impl Into<BrTarget<Label>>) { + match label.into() { + BrTarget::Return => self.ret(), + BrTarget::Label(label) => dynasm!(self.asm + ; jmp =>label.0 + ), + } + } + + /// If `default` is `None` then the default is just continuing execution + pub fn br_table<I>( + &mut self, + targets: I, + default: Option<BrTarget<Label>>, + pass_args: impl FnOnce(&mut Self) -> Result<(), Error>, + ) -> Result<(), Error> + where + I: IntoIterator<Item = Option<BrTarget<Label>>>, + I::IntoIter: ExactSizeIterator, + { + let mut targets = targets.into_iter(); + let count = targets.len(); + + let mut selector = self.pop()?; + + pass_args(self)?; + + if let Some(imm) = selector.imm_i32() { + if let Some(target) = targets.nth(imm as _).or(Some(default)).and_then(|a| a) { + match target { + BrTarget::Label(label) => self.br(label), + BrTarget::Return => { + dynasm!(self.asm + ; ret + ); + } + } + } + } else { + let end_label = self.create_label(); + + if count > 0 { + let temp = match self.put_into_temp_register(GPRType::Rq, &mut selector) { + Err(e) => return Err(e), + Ok(o) => match o { + Some(r) => Ok((r, false)), + None => { + self.push_physical(ValueLocation::Reg(RAX))?; + self.block_state.regs.mark_used(RAX); + Ok((RAX, true)) + } + }, + }; + + let (selector_reg, pop_selector) = match temp { + Err(e) => return Err(e), + Ok(a) => a, + }; + + let (tmp, pop_tmp) = if let Some(reg) = self.take_reg(I64) { + (reg, false) + } else { + let out_reg = if selector_reg == RAX { RCX } else { RAX }; + + self.push_physical(ValueLocation::Reg(out_reg))?; + self.block_state.regs.mark_used(out_reg); + + (out_reg, true) + }; + + self.immediate_to_reg(tmp, (count as u32).into()); + dynasm!(self.asm + ; cmp Rq(selector_reg.rq().unwrap()), Rq(tmp.rq().unwrap()) + ; cmova Rq(selector_reg.rq().unwrap()), Rq(tmp.rq().unwrap()) + ; lea Rq(tmp.rq().unwrap()), [>start_label] + ; lea Rq(selector_reg.rq().unwrap()), [ + Rq(selector_reg.rq().unwrap()) * 5 + ] + ; add Rq(selector_reg.rq().unwrap()), Rq(tmp.rq().unwrap()) + ); + + if pop_tmp { + dynasm!(self.asm + ; pop Rq(tmp.rq().unwrap()) + ); + } else { + self.block_state.regs.release(tmp)?; + } + + if pop_selector { + dynasm!(self.asm + ; pop Rq(selector_reg.rq().unwrap()) + ); + } + + dynasm!(self.asm + ; jmp Rq(selector_reg.rq().unwrap()) + ; start_label: + ); + + for target in targets { + let label = target + .map(|target| self.target_to_label(target)) + .unwrap_or(end_label); + dynasm!(self.asm + ; jmp =>label.0 + ); + } + } + + if let Some(def) = default { + match def { + BrTarget::Label(label) => dynasm!(self.asm + ; jmp =>label.0 + ), + BrTarget::Return => dynasm!(self.asm + ; ret + ), + } + } + + self.define_label(end_label); + } + + self.free_value(selector)?; + Ok(()) + } + + fn set_stack_depth(&mut self, depth: StackDepth) -> Result<(), Error> { + if self.block_state.depth.0 != depth.0 { + let diff = depth.0 as i32 - self.block_state.depth.0 as i32; + let emit_lea = if diff.abs() != 1 { + true + } else { + match self.block_state.depth.0.cmp(&depth.0) { + Ordering::Less => { + for _ in 0..diff { + dynasm!(self.asm + ; push rax + ); + } + false + } + Ordering::Greater => { + if let Some(trash) = self.take_reg(I64) { + for _ in 0..self.block_state.depth.0 - depth.0 { + dynasm!(self.asm + ; pop Rq(trash.rq().unwrap()) + ); + } + self.block_state.regs.release(trash)?; + false + } else { + true + } + } + Ordering::Equal => false, + } + }; + if emit_lea { + dynasm!(self.asm + ; lea rsp, [rsp + (self.block_state.depth.0 as i32 - depth.0 as i32) * WORD_SIZE as i32] + ); + } + self.block_state.depth = depth; + } + Ok(()) + } + + fn do_pass_block_args(&mut self, cc: &BlockCallingConvention) -> Result<(), Error> { + let args = &cc.arguments; + for &dst in args.iter().rev().take(self.block_state.stack.len()) { + if let CCLoc::Reg(r) = dst { + if !self.block_state.regs.is_free(r) + && *self.block_state.stack.last().unwrap() != ValueLocation::Reg(r) + { + // TODO: This would be made simpler and more efficient with a proper SSE + // representation. + self.save_regs(&[r], ..)?; + } + + self.block_state.regs.mark_used(r); + } + self.pop_into(dst)?; + } + Ok(()) + } + + pub fn pass_block_args(&mut self, cc: &BlockCallingConvention) -> Result<(), Error> { + self.do_pass_block_args(cc)?; + self.set_stack_depth(cc.stack_depth)?; + Ok(()) + } + + pub fn serialize_block_args( + &mut self, + cc: &BlockCallingConvention, + params: u32, + ) -> Result<BlockCallingConvention, Error> { + self.do_pass_block_args(cc)?; + + let mut out_args = cc.arguments.clone(); + + out_args.reverse(); + + while out_args.len() < params as usize { + let mut val = self.pop()?; + + // TODO: We can use stack slots for values already on the stack but we + // don't refcount stack slots right now + let ccloc = self.put_into_temp_location(None, &mut val)?; + out_args.push(ccloc); + } + + out_args.reverse(); + + self.set_stack_depth(cc.stack_depth)?; + + Ok(BlockCallingConvention { + stack_depth: cc.stack_depth, + arguments: out_args, + }) + } + + /// Puts all stack values into "real" locations so that they can i.e. be set to different + /// values on different iterations of a loop + pub fn serialize_args(&mut self, count: u32) -> Result<BlockCallingConvention, Error> { + let mut out = Vec::with_capacity(count as _); + + // TODO: We can make this more efficient now that `pop` isn't so complicated + for _ in 0..count { + let mut val = self.pop()?; + // TODO: We can use stack slots for values already on the stack but we + // don't refcount stack slots right now + let loc = self.put_into_temp_location(None, &mut val)?; + + out.push(loc); + } + + out.reverse(); + + Ok(BlockCallingConvention { + stack_depth: self.block_state.depth, + arguments: out, + }) + } + + pub fn get_global(&mut self, global_idx: u32) -> Result<(), Error> { + let (reg, offset) = self + .module_context + .defined_global_index(global_idx) + .map(|defined_global_index| { + ( + None, + self.module_context + .vmctx_vmglobal_definition(defined_global_index), + ) + }) + .unwrap_or_else(|| { + let reg = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; mov Rq(reg.rq().unwrap()), [ + Rq(VMCTX) + + self.module_context.vmctx_vmglobal_import_from(global_idx) as i32 + ] + ); + + (Some(reg), 0) + }); + + let out = self.take_reg(GPRType::Rq).unwrap(); + let vmctx = GPR::Rq(VMCTX); + + // TODO: Are globals necessarily aligned to 128 bits? We can load directly to an XMM reg if so + dynasm!(self.asm + ; mov Rq(out.rq().unwrap()), [Rq(reg.unwrap_or(vmctx).rq().unwrap()) + offset as i32] + ); + + if let Some(reg) = reg { + self.block_state.regs.release(reg)?; + } + + self.push(ValueLocation::Reg(out))?; + Ok(()) + } + + pub fn set_global(&mut self, global_idx: u32) -> Result<(), Error> { + let mut val = self.pop()?; + let (reg, offset) = self + .module_context + .defined_global_index(global_idx) + .map(|defined_global_index| { + ( + None, + self.module_context + .vmctx_vmglobal_definition(defined_global_index), + ) + }) + .unwrap_or_else(|| { + let reg = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; mov Rq(reg.rq().unwrap()), [ + Rq(VMCTX) + + self.module_context.vmctx_vmglobal_import_from(global_idx) as i32 + ] + ); + + (Some(reg), 0) + }); + + let val_reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let vmctx = GPR::Rq(VMCTX); + + // We always use `Rq` (even for floats) since the globals are not necessarily aligned to 128 bits + dynasm!(self.asm + ; mov [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + offset as i32 + ], Rq(val_reg.rq().unwrap()) + ); + + if let Some(reg) = reg { + self.block_state.regs.release(reg)?; + } + + self.free_value(val)?; + Ok(()) + } + + fn immediate_to_reg(&mut self, reg: GPR, val: Value) { + match reg { + GPR::Rq(r) => { + let val = val.as_bytes(); + if (val as u64) <= u32::max_value() as u64 { + dynasm!(self.asm + ; mov Rd(r), val as i32 + ); + } else { + dynasm!(self.asm + ; mov Rq(r), QWORD val + ); + } + } + GPR::Rx(r) => { + let label = self.aligned_label(16, LabelValue::from(val)); + dynasm!(self.asm + ; movq Rx(r), [=>label.0] + ); + } + } + } + + // The `&` and `&mut` aren't necessary (`ValueLocation` is copy) but it ensures that we don't get + // the arguments the wrong way around. In the future we want to have a `ReadLocation` and `WriteLocation` + // so we statically can't write to a literal so this will become a non-issue. + fn copy_value(&mut self, src: ValueLocation, dst: CCLoc) -> Result<(), Error> { + match (src, dst) { + (ValueLocation::Cond(cond), CCLoc::Stack(o)) => { + let offset = self.adjusted_offset(o); + + dynasm!(self.asm + ; mov QWORD [rsp + offset], DWORD 0 + ); + + match cond { + cc::EQUAL => dynasm!(self.asm + ; sete [rsp + offset] + ), + cc::NOT_EQUAL => dynasm!(self.asm + ; setne [rsp + offset] + ), + cc::GT_U => dynasm!(self.asm + ; seta [rsp + offset] + ), + cc::GE_U => dynasm!(self.asm + ; setae [rsp + offset] + ), + cc::LT_U => dynasm!(self.asm + ; setb [rsp + offset] + ), + cc::LE_U => dynasm!(self.asm + ; setbe [rsp + offset] + ), + cc::GT_S => dynasm!(self.asm + ; setg [rsp + offset] + ), + cc::GE_S => dynasm!(self.asm + ; setge [rsp + offset] + ), + cc::LT_S => dynasm!(self.asm + ; setl [rsp + offset] + ), + cc::LE_S => dynasm!(self.asm + ; setle [rsp + offset] + ), + } + } + (ValueLocation::Cond(cond), CCLoc::Reg(reg)) => match reg { + GPR::Rq(r) => { + dynasm!(self.asm + ; mov Rq(r), 0 + ); + + match cond { + cc::EQUAL => dynasm!(self.asm + ; sete Rb(r) + ), + cc::NOT_EQUAL => dynasm!(self.asm + ; setne Rb(r) + ), + cc::GT_U => dynasm!(self.asm + ; seta Rb(r) + ), + cc::GE_U => dynasm!(self.asm + ; setae Rb(r) + ), + cc::LT_U => dynasm!(self.asm + ; setb Rb(r) + ), + cc::LE_U => dynasm!(self.asm + ; setbe Rb(r) + ), + cc::GT_S => dynasm!(self.asm + ; setg Rb(r) + ), + cc::GE_S => dynasm!(self.asm + ; setge Rb(r) + ), + cc::LT_S => dynasm!(self.asm + ; setl Rb(r) + ), + cc::LE_S => dynasm!(self.asm + ; setle Rb(r) + ), + } + } + GPR::Rx(_) => { + let temp = CCLoc::Reg(self.take_reg(I32).unwrap()); + self.copy_value(src, temp)?; + let temp = temp.into(); + self.copy_value(temp, dst)?; + self.free_value(temp)?; + } + }, + (ValueLocation::Stack(in_offset), CCLoc::Stack(out_offset)) => { + let in_offset = self.adjusted_offset(in_offset); + let out_offset = self.adjusted_offset(out_offset); + if in_offset != out_offset { + if let Some(gpr) = self.take_reg(I64) { + dynasm!(self.asm + ; mov Rq(gpr.rq().unwrap()), [rsp + in_offset] + ; mov [rsp + out_offset], Rq(gpr.rq().unwrap()) + ); + self.block_state.regs.release(gpr)?; + } else { + dynasm!(self.asm + ; push rax + ; mov rax, [rsp + in_offset + WORD_SIZE as i32] + ; mov [rsp + out_offset + WORD_SIZE as i32], rax + ; pop rax + ); + } + } + } + // TODO: XMM registers + (ValueLocation::Reg(in_reg), CCLoc::Stack(out_offset)) => { + let out_offset = self.adjusted_offset(out_offset); + match in_reg { + GPR::Rq(in_reg) => { + // We can always use `Rq` here for now because stack slots are in multiples of + // 8 bytes + dynasm!(self.asm + ; mov [rsp + out_offset], Rq(in_reg) + ); + } + GPR::Rx(in_reg) => { + // We can always use `movq` here for now because stack slots are in multiples of + // 8 bytes + dynasm!(self.asm + ; movq [rsp + out_offset], Rx(in_reg) + ); + } + } + } + (ValueLocation::Immediate(i), CCLoc::Stack(out_offset)) => { + // TODO: Floats + let i = i.as_bytes(); + let out_offset = self.adjusted_offset(out_offset); + if (i as u64) <= u32::max_value() as u64 { + dynasm!(self.asm + ; mov DWORD [rsp + out_offset], i as i32 + ); + } else if let Some(scratch) = self.take_reg(I64) { + dynasm!(self.asm + ; mov Rq(scratch.rq().unwrap()), QWORD i + ; mov [rsp + out_offset], Rq(scratch.rq().unwrap()) + ); + + self.block_state.regs.release(scratch)?; + } else { + dynasm!(self.asm + ; push rax + ; mov rax, QWORD i + ; mov [rsp + out_offset + WORD_SIZE as i32], rax + ; pop rax + ); + } + } + (ValueLocation::Stack(in_offset), CCLoc::Reg(out_reg)) => { + let in_offset = self.adjusted_offset(in_offset); + match out_reg { + GPR::Rq(out_reg) => { + // We can always use `Rq` here for now because stack slots are in multiples of + // 8 bytes + dynasm!(self.asm + ; mov Rq(out_reg), [rsp + in_offset] + ); + } + GPR::Rx(out_reg) => { + // We can always use `movq` here for now because stack slots are in multiples of + // 8 bytes + dynasm!(self.asm + ; movq Rx(out_reg), [rsp + in_offset] + ); + } + } + } + (ValueLocation::Reg(in_reg), CCLoc::Reg(out_reg)) => { + if in_reg != out_reg { + match (in_reg, out_reg) { + (GPR::Rq(in_reg), GPR::Rq(out_reg)) => { + dynasm!(self.asm + ; mov Rq(out_reg), Rq(in_reg) + ); + } + (GPR::Rx(in_reg), GPR::Rq(out_reg)) => { + dynasm!(self.asm + ; movq Rq(out_reg), Rx(in_reg) + ); + } + (GPR::Rq(in_reg), GPR::Rx(out_reg)) => { + dynasm!(self.asm + ; movq Rx(out_reg), Rq(in_reg) + ); + } + (GPR::Rx(in_reg), GPR::Rx(out_reg)) => { + dynasm!(self.asm + ; movapd Rx(out_reg), Rx(in_reg) + ); + } + } + } + } + (ValueLocation::Immediate(i), CCLoc::Reg(out_reg)) => { + // TODO: Floats + self.immediate_to_reg(out_reg, i); + } + } + Ok(()) + } + + /// Define the given label at the current position. + /// + /// Multiple labels can be defined at the same position. However, a label + /// can be defined only once. + pub fn define_label(&mut self, label: Label) { + self.asm.dynamic_label(label.0); + } + + pub fn set_state(&mut self, state: VirtualCallingConvention) -> Result<(), Error> { + self.block_state.regs = Registers::new(); + self.block_state.regs.release_scratch_register()?; + for elem in &state.stack { + if let ValueLocation::Reg(r) = elem { + self.block_state.regs.mark_used(*r); + } + } + self.block_state.stack = state.stack; + self.block_state.depth = state.depth; + Ok(()) + } + + pub fn apply_cc(&mut self, cc: &BlockCallingConvention) -> Result<(), Error> { + let stack = cc.arguments.iter(); + + self.block_state.stack = Vec::with_capacity(stack.size_hint().0); + self.block_state.regs = Registers::new(); + self.block_state.regs.release_scratch_register()?; + + for &elem in stack { + if let CCLoc::Reg(r) = elem { + self.block_state.regs.mark_used(r); + } + + self.block_state.stack.push(elem.into()); + } + + self.block_state.depth = cc.stack_depth; + Ok(()) + } + + load!(i32_load, GPRType::Rq, Rd, movd, mov, DWORD); + load!(i64_load, GPRType::Rq, Rq, movq, mov, QWORD); + load!(f32_load, GPRType::Rx, Rd, movd, mov, DWORD); + load!(f64_load, GPRType::Rx, Rq, movq, mov, QWORD); + + load!(i32_load8_u, GPRType::Rq, Rd, NONE, movzx, BYTE); + load!(i32_load8_s, GPRType::Rq, Rd, NONE, movsx, BYTE); + load!(i32_load16_u, GPRType::Rq, Rd, NONE, movzx, WORD); + load!(i32_load16_s, GPRType::Rq, Rd, NONE, movsx, WORD); + + load!(i64_load8_u, GPRType::Rq, Rq, NONE, movzx, BYTE); + load!(i64_load8_s, GPRType::Rq, Rq, NONE, movsx, BYTE); + load!(i64_load16_u, GPRType::Rq, Rq, NONE, movzx, WORD); + load!(i64_load16_s, GPRType::Rq, Rq, NONE, movsx, WORD); + load!(i64_load32_u, GPRType::Rq, Rd, movd, mov, DWORD); + load!(i64_load32_s, GPRType::Rq, Rq, NONE, movsxd, DWORD); + + store!(store8, Rb, NONE, DWORD); + store!(store16, Rw, NONE, QWORD); + store!(store32, Rd, movd, DWORD); + store!(store64, Rq, movq, QWORD); + + fn push_physical(&mut self, mut value: ValueLocation) -> Result<ValueLocation, Error> { + let out_offset = -(self.block_state.depth.0 as i32 + 1); + match value { + ValueLocation::Reg(_) | ValueLocation::Immediate(_) | ValueLocation::Cond(_) => { + if let Some(gpr) = self.put_into_register(GPRType::Rq, &mut value)? { + dynasm!(self.asm + ; push Rq(gpr.rq().unwrap()) + ); + } else { + dynasm!(self.asm + ; push rax + ); + + self.copy_value(value, CCLoc::Stack(out_offset))?; + } + + self.free_value(value)?; + } + ValueLocation::Stack(o) => { + let offset = self.adjusted_offset(o); + dynasm!(self.asm + ; push QWORD [rsp + offset] + ); + } + } + + self.block_state.depth.reserve(1); + + Ok(ValueLocation::Stack(out_offset)) + } + + fn push(&mut self, value: ValueLocation) -> Result<(), Error> { + if let Some(mut top) = self.block_state.stack.pop() { + if let ValueLocation::Cond(_) = top { + match self.put_into_register(I32, &mut top) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + } + + self.block_state.stack.push(top); + } + + self.block_state.stack.push(value); + Ok(()) + } + + fn pop(&mut self) -> Result<ValueLocation, Error> { + match self.block_state.stack.pop() { + Some(v) => Ok(v), + None => Err(Error::Microwasm( + "Stack is empty - pop impossible".to_string(), + )), + } + } + + pub fn drop(&mut self, range: RangeInclusive<u32>) -> Result<(), Error> { + let mut repush = Vec::with_capacity(*range.start() as _); + + for _ in 0..*range.start() { + let v = self.pop()?; + repush.push(v); + } + + for _ in range { + let val = self.pop()?; + self.free_value(val)?; + } + + for v in repush.into_iter().rev() { + self.push(v)?; + } + Ok(()) + } + + fn pop_into(&mut self, dst: CCLoc) -> Result<(), Error> { + let val = self.pop()?; + self.copy_value(val, dst)?; + self.free_value(val)?; + Ok(()) + } + + fn free_value(&mut self, val: ValueLocation) -> Result<(), Error> { + if let ValueLocation::Reg(r) = val { + self.block_state.regs.release(r)?; + } + Ok(()) + } + + /// Puts this value into a register so that it can be efficiently read + fn put_into_register( + &mut self, + ty: impl Into<Option<GPRType>>, + val: &mut ValueLocation, + ) -> Result<Option<GPR>, Error> { + if let Some(out) = self.clone_to_register(ty, *val)? { + self.free_value(*val)?; + *val = ValueLocation::Reg(out); + Ok(Some(out)) + } else { + Ok(None) + } + } + + /// Clones this value into a register so that it can be efficiently read + fn clone_to_register( + &mut self, + ty: impl Into<Option<GPRType>>, + val: ValueLocation, + ) -> Result<Option<GPR>, Error> { + let ty = ty.into(); + match val { + ValueLocation::Reg(r) if ty.map(|t| t == r.type_()).unwrap_or(true) => { + self.block_state.regs.mark_used(r); + Ok(Some(r)) + } + val => match self.take_reg(ty.unwrap_or(GPRType::Rq)) { + Some(scratch) => { + self.copy_value(val, CCLoc::Reg(scratch))?; + Ok(Some(scratch)) + } + None => Ok(None), + }, + } + } + + /// Puts this value into a temporary register so that operations + /// on that register don't write to a local. + fn put_into_temp_register( + &mut self, + ty: impl Into<Option<GPRType>>, + val: &mut ValueLocation, + ) -> Result<Option<GPR>, Error> { + let out = self.clone_to_temp_register(ty, *val)?; + if let Some(o) = out { + self.free_value(*val)?; + *val = ValueLocation::Reg(o); + Ok(Some(o)) + } else { + Ok(None) + } + } + + fn put_into_temp_location( + &mut self, + ty: impl Into<Option<GPRType>>, + val: &mut ValueLocation, + ) -> Result<CCLoc, Error> { + match val { + _ => { + if let Some(gpr) = self.put_into_temp_register(ty, val)? { + Ok(CCLoc::Reg(gpr)) + } else { + let out = CCLoc::Stack(self.push_physical(*val)?.stack().unwrap()); + *val = out.into(); + Ok(out) + } + } + } + } + + /// Clones this value into a temporary register so that operations + /// on that register don't write to a local. + + fn clone_to_temp_register( + &mut self, + ty: impl Into<Option<GPRType>>, + val: ValueLocation, + ) -> Result<Option<GPR>, Error> { + // If we have `None` as the type then it always matches (`.unwrap_or(true)`) + match val { + ValueLocation::Reg(r) => { + let ty = ty.into(); + let type_matches = ty.map(|t| t == r.type_()).unwrap_or(true); + + if self.block_state.regs.num_usages(r) <= 1 && type_matches { + self.block_state.regs.mark_used(r); + Ok(Some(r)) + } else if let Some(scratch) = self.take_reg(ty.unwrap_or(GPRType::Rq)) { + self.copy_value(val, CCLoc::Reg(scratch))?; + Ok(Some(scratch)) + } else { + Ok(None) + } + } + val => self.clone_to_register(ty, val), + } + } + + pub fn f32_neg(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f32() { + ValueLocation::Immediate( + Ieee32::from_bits((-f32::from_bits(i.to_bits())).to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let const_label = self.aligned_label(16, LabelValue::I32(SIGN_MASK_F32 as i32)); + + dynasm!(self.asm + ; xorps Rx(reg.rx().unwrap()), [=>const_label.0] + ); + + val + }; + + self.push(out)?; + Ok(()) + } + + pub fn f64_neg(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f64() { + ValueLocation::Immediate( + Ieee64::from_bits((-f64::from_bits(i.to_bits())).to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let const_label = self.aligned_label(16, LabelValue::I64(SIGN_MASK_F64 as i64)); + + dynasm!(self.asm + ; xorpd Rx(reg.rx().unwrap()), [=>const_label.0] + ); + + val + }; + + self.push(out)?; + Ok(()) + } + + pub fn f32_abs(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f32() { + ValueLocation::Immediate( + Ieee32::from_bits(f32::from_bits(i.to_bits()).abs().to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let const_label = self.aligned_label(16, LabelValue::I32(REST_MASK_F32 as i32)); + + dynasm!(self.asm + ; andps Rx(reg.rx().unwrap()), [=>const_label.0] + ); + + val + }; + + self.push(out)?; + Ok(()) + } + + pub fn f64_abs(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f64() { + ValueLocation::Immediate( + Ieee64::from_bits(f64::from_bits(i.to_bits()).abs().to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let const_label = self.aligned_label(16, LabelValue::I64(REST_MASK_F64 as i64)); + + dynasm!(self.asm + ; andps Rx(reg.rx().unwrap()), [=>const_label.0] + ); + + val + }; + + self.push(out)?; + Ok(()) + } + + pub fn f32_sqrt(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f32() { + ValueLocation::Immediate( + Ieee32::from_bits(f32::from_bits(i.to_bits()).sqrt().to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; sqrtss Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ); + + val + }; + + self.push(out)?; + Ok(()) + } + + pub fn f64_sqrt(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out = if let Some(i) = val.imm_f64() { + ValueLocation::Immediate( + Ieee64::from_bits(f64::from_bits(i.to_bits()).sqrt().to_bits()).into(), + ) + } else { + let reg = match self.put_into_temp_register(GPRType::Rx, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; sqrtsd Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ); + + ValueLocation::Reg(reg) + }; + + self.push(out)?; + Ok(()) + } + + pub fn f32_copysign(&mut self) -> Result<(), Error> { + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = if let (Some(left), Some(right)) = (left.imm_f32(), right.imm_f32()) { + ValueLocation::Immediate( + Ieee32::from_bits( + (left.to_bits() & REST_MASK_F32) | (right.to_bits() & SIGN_MASK_F32), + ) + .into(), + ) + } else { + let lreg = match self.put_into_temp_register(GPRType::Rx, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let rreg = match self.put_into_register(GPRType::Rx, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let sign_mask = self.aligned_label(16, LabelValue::I32(SIGN_MASK_F32 as i32)); + let rest_mask = self.aligned_label(16, LabelValue::I32(REST_MASK_F32 as i32)); + + dynasm!(self.asm + ; andps Rx(rreg.rx().unwrap()), [=>sign_mask.0] + ; andps Rx(lreg.rx().unwrap()), [=>rest_mask.0] + ; orps Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ); + + self.free_value(right)?; + + left + }; + + self.push(out)?; + Ok(()) + } + + pub fn f64_copysign(&mut self) -> Result<(), Error> { + let mut right = self.pop()?; + let mut left = self.pop()?; + + let out = if let (Some(left), Some(right)) = (left.imm_f64(), right.imm_f64()) { + ValueLocation::Immediate( + Ieee64::from_bits( + (left.to_bits() & REST_MASK_F64) | (right.to_bits() & SIGN_MASK_F64), + ) + .into(), + ) + } else { + let lreg = match self.put_into_temp_register(GPRType::Rx, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let rreg = match self.put_into_register(GPRType::Rx, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let sign_mask = self.aligned_label(16, LabelValue::I64(SIGN_MASK_F64 as i64)); + let rest_mask = self.aligned_label(16, LabelValue::I64(REST_MASK_F64 as i64)); + + dynasm!(self.asm + ; andpd Rx(rreg.rx().unwrap()), [=>sign_mask.0] + ; andpd Rx(lreg.rx().unwrap()), [=>rest_mask.0] + ; orpd Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap()) + ); + + self.free_value(right)?; + + left + }; + + self.push(out)?; + Ok(()) + } + + pub fn i32_clz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(imm.as_i32().unwrap().leading_zeros().into()) + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(I32).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; lzcnt Rd(temp.rq().unwrap()), [rsp + offset] + ); + ValueLocation::Reg(temp) + } else { + let temp_2 = self.take_reg(I32).unwrap(); + + dynasm!(self.asm + ; bsr Rd(temp.rq().unwrap()), [rsp + offset] + ; mov Rd(temp_2.rq().unwrap()), DWORD 0x3fu64 as _ + ; cmove Rd(temp.rq().unwrap()), Rd(temp_2.rq().unwrap()) + ; mov Rd(temp_2.rq().unwrap()), DWORD 0x1fu64 as _ + ; xor Rd(temp.rq().unwrap()), Rd(temp_2.rq().unwrap()) + ); + self.free_value(ValueLocation::Reg(temp_2))?; + ValueLocation::Reg(temp) + } + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; lzcnt Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } else { + dynasm!(self.asm + ; bsr Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ; mov Rd(reg.rq().unwrap()), DWORD 0x3fu64 as _ + ; cmove Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ; mov Rd(reg.rq().unwrap()), DWORD 0x1fu64 as _ + ; xor Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } + } + }; + + self.free_value(val)?; + self.push(out_val)?; + Ok(()) + } + + pub fn i64_clz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate((imm.as_i64().unwrap().leading_zeros() as u64).into()) + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(I64).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; lzcnt Rq(temp.rq().unwrap()), [rsp + offset] + ); + ValueLocation::Reg(temp) + } else { + let temp_2 = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; bsr Rq(temp.rq().unwrap()), [rsp + offset] + ; mov Rq(temp_2.rq().unwrap()), QWORD 0x7fu64 as _ + ; cmove Rq(temp.rq().unwrap()), Rq(temp_2.rq().unwrap()) + ; mov Rq(temp_2.rq().unwrap()), QWORD 0x3fu64 as _ + ; xor Rq(temp.rq().unwrap()), Rq(temp_2.rq().unwrap()) + ); + self.free_value(ValueLocation::Reg(temp_2))?; + ValueLocation::Reg(temp) + } + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(I64).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; lzcnt Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } else { + dynasm!(self.asm + ; bsr Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ; mov Rq(reg.rq().unwrap()), QWORD 0x7fu64 as _ + ; cmove Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ; mov Rq(reg.rq().unwrap()), QWORD 0x3fu64 as _ + ; xor Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } + } + }; + + self.free_value(val)?; + self.push(out_val)?; + Ok(()) + } + + pub fn i32_ctz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(imm.as_i32().unwrap().trailing_zeros().into()) + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(I32).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; tzcnt Rd(temp.rq().unwrap()), [rsp + offset] + ); + ValueLocation::Reg(temp) + } else { + let temp_zero_val = self.take_reg(I32).unwrap(); + + dynasm!(self.asm + ; bsf Rd(temp.rq().unwrap()), [rsp + offset] + ; mov Rd(temp_zero_val.rq().unwrap()), DWORD 0x20u32 as _ + ; cmove Rd(temp.rq().unwrap()), Rd(temp_zero_val.rq().unwrap()) + ); + self.free_value(ValueLocation::Reg(temp_zero_val))?; + ValueLocation::Reg(temp) + } + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(I32).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; tzcnt Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } else { + dynasm!(self.asm + ; bsf Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ; mov Rd(reg.rq().unwrap()), DWORD 0x20u32 as _ + ; cmove Rd(temp.rq().unwrap()), Rd(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } + } + }; + + self.free_value(val)?; + self.push(out_val)?; + Ok(()) + } + + pub fn i64_ctz(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate((imm.as_i64().unwrap().trailing_zeros() as u64).into()) + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + let temp = self.take_reg(I64).unwrap(); + + if is_x86_feature_detected!("lzcnt") { + dynasm!(self.asm + ; tzcnt Rq(temp.rq().unwrap()), [rsp + offset] + ); + ValueLocation::Reg(temp) + } else { + let temp_zero_val = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; bsf Rq(temp.rq().unwrap()), [rsp + offset] + ; mov Rq(temp_zero_val.rq().unwrap()), QWORD 0x40u64 as _ + ; cmove Rq(temp.rq().unwrap()), Rq(temp_zero_val.rq().unwrap()) + ); + self.free_value(ValueLocation::Reg(temp_zero_val))?; + ValueLocation::Reg(temp) + } + } + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let reg = match self.put_into_register(GPRType::Rq, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; bsf Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ; mov Rq(reg.rq().unwrap()), QWORD 0x40u64 as _ + ; cmove Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + self.push(out_val)?; + Ok(()) + } + + pub fn i32_extend_u(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = if let ValueLocation::Immediate(imm) = val { + ValueLocation::Immediate((imm.as_i32().unwrap() as u32 as u64).into()) + } else { + let new_reg = self.take_reg(I64).unwrap(); + + // TODO: Track set-ness of bits - we can make this a no-op in most cases + // but we have to make this unconditional just in case this value + // came from a truncate. + match val { + ValueLocation::Reg(GPR::Rx(rxreg)) => { + dynasm!(self.asm + ; movd Rd(new_reg.rq().unwrap()), Rx(rxreg) + ); + } + ValueLocation::Reg(GPR::Rq(rqreg)) => { + dynasm!(self.asm + ; mov Rd(new_reg.rq().unwrap()), Rd(rqreg) + ); + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + dynasm!(self.asm + ; mov Rd(new_reg.rq().unwrap()), [rsp + offset] + ); + } + ValueLocation::Cond(_) => self.copy_value(val, CCLoc::Reg(new_reg))?, + ValueLocation::Immediate(_) => { + return Err(Error::Microwasm( + "i32_extend_u unreachable code".to_string(), + )) + } + } + + ValueLocation::Reg(new_reg) + }; + + self.free_value(val)?; + + self.push(out)?; + Ok(()) + } + + pub fn i32_extend_s(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + self.free_value(val)?; + let new_reg = self.take_reg(I64).unwrap(); + + let out = if let ValueLocation::Immediate(imm) = val { + self.block_state.regs.release(new_reg)?; + ValueLocation::Immediate((imm.as_i32().unwrap() as i64).into()) + } else { + match val { + ValueLocation::Reg(GPR::Rx(rxreg)) => { + dynasm!(self.asm + ; movd Rd(new_reg.rq().unwrap()), Rx(rxreg) + ; movsxd Rq(new_reg.rq().unwrap()), Rd(new_reg.rq().unwrap()) + ); + } + ValueLocation::Reg(GPR::Rq(rqreg)) => { + dynasm!(self.asm + ; movsxd Rq(new_reg.rq().unwrap()), Rd(rqreg) + ); + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + dynasm!(self.asm + ; movsxd Rq(new_reg.rq().unwrap()), DWORD [rsp + offset] + ); + } + _ => { + return Err(Error::Microwasm( + "i32_extend_s unreachable code".to_string(), + )) + } + } + + ValueLocation::Reg(new_reg) + }; + + self.push(out)?; + Ok(()) + } + + unop!(i32_popcnt, popcnt, Rd, u32, u32::count_ones); + conversion!( + f64_from_f32, + cvtss2sd, + Rx, + rx, + Rx, + rx, + f32, + f64, + as_f32, + |a: Ieee32| Ieee64::from_bits((f32::from_bits(a.to_bits()) as f64).to_bits()) + ); + conversion!( + f32_from_f64, + cvtsd2ss, + Rx, + rx, + Rx, + rx, + f64, + f32, + as_f64, + |a: Ieee64| Ieee32::from_bits((f64::from_bits(a.to_bits()) as f32).to_bits()) + ); + pub fn i32_truncate_f32_s(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f32::from_bits(imm.as_f32().unwrap().to_bits()) as i32).into(), + ), + _ => { + let reg = match self.put_into_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(4, LabelValue::I32(SIGN_MASK_F32 as i32)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I32(0xCF00_0000_u32 as i32)); + let zero = self.aligned_label(16, LabelValue::I32(0)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; cvttss2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rd(temp.rq().unwrap()), [=>sign_mask.0] + ; jne >ret + ; ucomiss Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ; jp =>trap_label.0 + ; ucomiss Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jnae =>trap_label.0 + ; ucomiss Rx(reg.rx().unwrap()), [=>zero.0] + ; jnb =>trap_label.0 + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i32_truncate_f32_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f32::from_bits(imm.as_f32().unwrap().to_bits()) as i32).into(), + ), + _ => { + let reg = match self.put_into_temp_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(4, LabelValue::I32(SIGN_MASK_F32 as i32)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I32(0x4F00_0000_u32 as i32)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; ucomiss Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jae >else_ + ; jp =>trap_label.0 + ; cvttss2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rd(temp.rq().unwrap()), Rd(temp.rq().unwrap()) + ; js =>trap_label.0 + ; jmp >ret + ; else_: + ; subss Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; cvttss2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rd(temp.rq().unwrap()), Rd(temp.rq().unwrap()) + ; js =>trap_label.0 + ; add Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i32_truncate_f64_s(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f64::from_bits(imm.as_f64().unwrap().to_bits()) as i32).into(), + ), + _ => { + let reg = match self.put_into_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(4, LabelValue::I32(SIGN_MASK_F32 as i32)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I64(0xC1E0_0000_0020_0000_u64 as i64)); + let zero = self.aligned_label(16, LabelValue::I64(0)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; cvttsd2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rd(temp.rq().unwrap()), [=>sign_mask.0] + ; jne >ret + ; ucomisd Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ; jp =>trap_label.0 + ; ucomisd Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jna =>trap_label.0 + ; ucomisd Rx(reg.rx().unwrap()), [=>zero.0] + ; jnb =>trap_label.0 + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i32_truncate_f64_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f64::from_bits(imm.as_f64().unwrap().to_bits()) as u32).into(), + ), + _ => { + let reg = match self.put_into_temp_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(4, LabelValue::I32(SIGN_MASK_F32 as i32)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I64(0x41E0_0000_0000_0000_u64 as i64)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; ucomisd Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jae >else_ + ; jp =>trap_label.0 + ; cvttsd2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rd(temp.rq().unwrap()), Rd(temp.rq().unwrap()) + ; js =>trap_label.0 + ; jmp >ret + ; else_: + ; subsd Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; cvttsd2si Rd(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rd(temp.rq().unwrap()), Rd(temp.rq().unwrap()) + ; js =>trap_label.0 + ; add Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + conversion!( + f32_convert_from_i32_s, + cvtsi2ss, + Rd, + rq, + Rx, + rx, + i32, + f32, + as_i32, + |a| Ieee32::from_bits((a as f32).to_bits()) + ); + conversion!( + f64_convert_from_i32_s, + cvtsi2sd, + Rd, + rq, + Rx, + rx, + i32, + f64, + as_i32, + |a| Ieee64::from_bits((a as f64).to_bits()) + ); + conversion!( + f32_convert_from_i64_s, + cvtsi2ss, + Rq, + rq, + Rx, + rx, + i64, + f32, + as_i64, + |a| Ieee32::from_bits((a as f32).to_bits()) + ); + conversion!( + f64_convert_from_i64_s, + cvtsi2sd, + Rq, + rq, + Rx, + rx, + i64, + f64, + as_i64, + |a| Ieee64::from_bits((a as f64).to_bits()) + ); + + pub fn i64_truncate_f32_s(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f32::from_bits(imm.as_f32().unwrap().to_bits()) as i64).into(), + ), + _ => { + let reg = match self.put_into_temp_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(16, LabelValue::I64(SIGN_MASK_F64 as i64)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I32(0xDF00_0000_u32 as i32)); + let zero = self.aligned_label(16, LabelValue::I64(0)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; cvttss2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; jne >ret + ; ucomiss Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ; jp =>trap_label.0 + ; ucomiss Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jnae =>trap_label.0 + ; ucomiss Rx(reg.rx().unwrap()), [=>zero.0] + ; jnb =>trap_label.0 + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i64_truncate_f64_s(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f64::from_bits(imm.as_f64().unwrap().to_bits()) as i64).into(), + ), + _ => { + let reg = match self.put_into_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I32).unwrap(); + + let sign_mask = self.aligned_label(8, LabelValue::I64(SIGN_MASK_F64 as i64)); + let float_cmp_mask = + self.aligned_label(16, LabelValue::I64(0xC3E0_0000_0000_0000_u64 as i64)); + let zero = self.aligned_label(16, LabelValue::I64(0)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; cvttsd2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; jne >ret + ; ucomisd Rx(reg.rx().unwrap()), Rx(reg.rx().unwrap()) + ; jp =>trap_label.0 + ; ucomisd Rx(reg.rx().unwrap()), [=>float_cmp_mask.0] + ; jnae =>trap_label.0 + ; ucomisd Rx(reg.rx().unwrap()), [=>zero.0] + ; jnb =>trap_label.0 + ; ret: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i64_truncate_f32_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f32::from_bits(imm.as_f32().unwrap().to_bits()) as u64).into(), + ), + _ => { + let reg = match self.put_into_register(F32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I64).unwrap(); + let sign_mask = self.aligned_label(16, LabelValue::I64(SIGN_MASK_F64 as i64)); + let u64_trunc_f32_const = self.aligned_label(16, LabelValue::I32(0x5F00_0000_i32)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; comiss Rx(reg.rx().unwrap()), [=>u64_trunc_f32_const.0] + ; jae >large + ; jp =>trap_label.0 + ; cvttss2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rq(temp.rq().unwrap()), Rq(temp.rq().unwrap()) + ; js =>trap_label.0 + ; jmp >cont + ; large: + ; subss Rx(reg.rx().unwrap()), [=>u64_trunc_f32_const.0] + ; cvttss2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; test Rq(temp.rq().unwrap()), Rq(temp.rq().unwrap()) + ; js =>trap_label.0 + ; add Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; cont: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i64_truncate_f64_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + (f64::from_bits(imm.as_f64().unwrap().to_bits()) as u64).into(), + ), + _ => { + let reg = match self.put_into_register(F64, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(I64).unwrap(); + + let sign_mask = self.aligned_label(16, LabelValue::I64(SIGN_MASK_F64 as i64)); + let u64_trunc_f64_const = + self.aligned_label(16, LabelValue::I64(0x43E0_0000_0000_0000_i64)); + let trap_label = self.trap_label(); + + dynasm!(self.asm + ; comisd Rx(reg.rx().unwrap()), [=>u64_trunc_f64_const.0] + ; jnb >large + ; jp =>trap_label.0 + ; cvttsd2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rq(temp.rq().unwrap()), 0 + ; jge >cont + ; jmp =>trap_label.0 + ; large: + ; subsd Rx(reg.rx().unwrap()), [=>u64_trunc_f64_const.0] + ; cvttsd2si Rq(temp.rq().unwrap()), Rx(reg.rx().unwrap()) + ; cmp Rq(temp.rq().unwrap()), 0 + ; jnge =>trap_label.0 + ; add Rq(temp.rq().unwrap()), [=>sign_mask.0] + ; cont: + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn f32_convert_from_i32_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + Ieee32::from_bits((imm.as_i32().unwrap() as u32 as f32).to_bits()).into(), + ), + _ => { + let reg = match self.put_into_register(I32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(F32).unwrap(); + + dynasm!(self.asm + ; mov Rd(reg.rq().unwrap()), Rd(reg.rq().unwrap()) + ; cvtsi2ss Rx(temp.rx().unwrap()), Rq(reg.rq().unwrap()) + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn f64_convert_from_i32_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + Ieee64::from_bits((imm.as_i32().unwrap() as u32 as f64).to_bits()).into(), + ), + _ => { + let reg = match self.put_into_register(I32, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let temp = self.take_reg(F64).unwrap(); + + dynasm!(self.asm + ; mov Rd(reg.rq().unwrap()), Rd(reg.rq().unwrap()) + ; cvtsi2sd Rx(temp.rx().unwrap()), Rq(reg.rq().unwrap()) + ); + + ValueLocation::Reg(temp) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn f32_convert_from_i64_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + Ieee32::from_bits((imm.as_i64().unwrap() as u64 as f32).to_bits()).into(), + ), + _ => { + let reg = match self.put_into_register(I64, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let out = self.take_reg(F32).unwrap(); + let temp = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; test Rq(reg.rq().unwrap()), Rq(reg.rq().unwrap()) + ; js >negative + ; cvtsi2ss Rx(out.rx().unwrap()), Rq(reg.rq().unwrap()) + ; jmp >ret + ; negative: + ; mov Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ; shr Rq(temp.rq().unwrap()), 1 + ; and Rq(reg.rq().unwrap()), 1 + ; or Rq(reg.rq().unwrap()), Rq(temp.rq().unwrap()) + ; cvtsi2ss Rx(out.rx().unwrap()), Rq(reg.rq().unwrap()) + ; addss Rx(out.rx().unwrap()), Rx(out.rx().unwrap()) + ; ret: + ); + + self.free_value(ValueLocation::Reg(temp))?; + + ValueLocation::Reg(out) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn f64_convert_from_i64_u(&mut self) -> Result<(), Error> { + let mut val = self.pop()?; + + let out_val = match val { + ValueLocation::Immediate(imm) => ValueLocation::Immediate( + Ieee64::from_bits((imm.as_i64().unwrap() as u64 as f64).to_bits()).into(), + ), + _ => { + let reg = match self.put_into_register(I64, &mut val) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let out = self.take_reg(F32).unwrap(); + let temp = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; test Rq(reg.rq().unwrap()), Rq(reg.rq().unwrap()) + ; js >negative + ; cvtsi2sd Rx(out.rx().unwrap()), Rq(reg.rq().unwrap()) + ; jmp >ret + ; negative: + ; mov Rq(temp.rq().unwrap()), Rq(reg.rq().unwrap()) + ; shr Rq(temp.rq().unwrap()), 1 + ; and Rq(reg.rq().unwrap()), 1 + ; or Rq(reg.rq().unwrap()), Rq(temp.rq().unwrap()) + ; cvtsi2sd Rx(out.rx().unwrap()), Rq(reg.rq().unwrap()) + ; addsd Rx(out.rx().unwrap()), Rx(out.rx().unwrap()) + ; ret: + ); + + self.free_value(ValueLocation::Reg(temp))?; + + ValueLocation::Reg(out) + } + }; + + self.free_value(val)?; + + self.push(out_val)?; + Ok(()) + } + + pub fn i32_wrap_from_i64(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate((imm.as_i64().unwrap() as u64 as u32).into()) + } + val => val, + }; + + self.push(out)?; + Ok(()) + } + + pub fn i32_reinterpret_from_f32(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(imm.as_f32().unwrap().to_bits().into()) + } + val => val, + }; + + self.push(out)?; + Ok(()) + } + + pub fn i64_reinterpret_from_f64(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(imm.as_f64().unwrap().to_bits().into()) + } + val => val, + }; + + self.push(out)?; + Ok(()) + } + + pub fn f32_reinterpret_from_i32(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(Ieee32::from_bits(imm.as_i32().unwrap() as _).into()) + } + val => val, + }; + + self.push(out)?; + Ok(()) + } + + pub fn f64_reinterpret_from_i64(&mut self) -> Result<(), Error> { + let val = self.pop()?; + + let out = match val { + ValueLocation::Immediate(imm) => { + ValueLocation::Immediate(Ieee64::from_bits(imm.as_i64().unwrap() as _).into()) + } + val => val, + }; + + self.push(out)?; + Ok(()) + } + + unop!(i64_popcnt, popcnt, Rq, u64, |a: u64| a.count_ones() as u64); + + // TODO: Use `lea` when the LHS operand isn't a temporary but both of the operands + // are in registers. + commutative_binop_i32!(i32_add, add, i32::wrapping_add); + commutative_binop_i32!(i32_and, and, |a, b| a & b); + commutative_binop_i32!(i32_or, or, |a, b| a | b); + commutative_binop_i32!(i32_xor, xor, |a, b| a ^ b); + binop_i32!(i32_sub, sub, i32::wrapping_sub); + + commutative_binop_i64!(i64_add, add, i64::wrapping_add); + commutative_binop_i64!(i64_and, and, |a, b| a & b); + commutative_binop_i64!(i64_or, or, |a, b| a | b); + commutative_binop_i64!(i64_xor, xor, |a, b| a ^ b); + binop_i64!(i64_sub, sub, i64::wrapping_sub); + + commutative_binop_f32!(f32_add, addss, |a, b| a + b); + commutative_binop_f32!(f32_mul, mulss, |a, b| a * b); + minmax_float!( + f32_min, + minss, + ucomiss, + addss, + orps, + as_f32, + |a: Ieee32, b: Ieee32| Ieee32::from_bits( + f32::from_bits(a.to_bits()) + .min(f32::from_bits(b.to_bits())) + .to_bits() + ) + ); + minmax_float!( + f32_max, + maxss, + ucomiss, + addss, + andps, + as_f32, + |a: Ieee32, b: Ieee32| Ieee32::from_bits( + f32::from_bits(a.to_bits()) + .max(f32::from_bits(b.to_bits())) + .to_bits() + ) + ); + binop_f32!(f32_sub, subss, |a, b| a - b); + binop_f32!(f32_div, divss, |a, b| a / b); + + pub fn f32_ceil(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::CeilF32), + iter::once(F32), + iter::once(F32), + true, + )?; + Ok(()) + } + + pub fn f32_floor(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::FloorF32), + iter::once(F32), + iter::once(F32), + true, + )?; + Ok(()) + } + + pub fn f32_nearest(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::NearestF32), + iter::once(F32), + iter::once(F32), + true, + )?; + Ok(()) + } + + pub fn f32_trunc(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::TruncF32), + iter::once(F32), + iter::once(F32), + true, + )?; + Ok(()) + } + + commutative_binop_f64!(f64_add, addsd, |a, b| a + b); + commutative_binop_f64!(f64_mul, mulsd, |a, b| a * b); + minmax_float!( + f64_min, + minsd, + ucomisd, + addsd, + orpd, + as_f64, + |a: Ieee64, b: Ieee64| Ieee64::from_bits( + f64::from_bits(a.to_bits()) + .min(f64::from_bits(b.to_bits())) + .to_bits() + ) + ); + minmax_float!( + f64_max, + maxsd, + ucomisd, + addsd, + andpd, + as_f64, + |a: Ieee64, b: Ieee64| Ieee64::from_bits( + f64::from_bits(a.to_bits()) + .max(f64::from_bits(b.to_bits())) + .to_bits() + ) + ); + binop_f64!(f64_sub, subsd, |a, b| a - b); + binop_f64!(f64_div, divsd, |a, b| a / b); + + pub fn f64_ceil(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::CeilF64), + iter::once(F64), + iter::once(F64), + true, + )?; + Ok(()) + } + + pub fn f64_floor(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::FloorF64), + iter::once(F64), + iter::once(F64), + true, + )?; + Ok(()) + } + + pub fn f64_nearest(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::NearestF64), + iter::once(F64), + iter::once(F64), + true, + )?; + Ok(()) + } + + pub fn f64_trunc(&mut self) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::LibCall(ir::LibCall::TruncF64), + iter::once(F64), + iter::once(F64), + true, + )?; + Ok(()) + } + + shift!( + i32_shl, + Rd, + shl, + |a, b| (a as i32).wrapping_shl(b as _), + I32 + ); + shift!( + i32_shr_s, + Rd, + sar, + |a, b| (a as i32).wrapping_shr(b as _), + I32 + ); + shift!( + i32_shr_u, + Rd, + shr, + |a, b| (a as u32).wrapping_shr(b as _), + I32 + ); + shift!( + i32_rotl, + Rd, + rol, + |a, b| (a as u32).rotate_left(b as _), + I32 + ); + shift!( + i32_rotr, + Rd, + ror, + |a, b| (a as u32).rotate_right(b as _), + I32 + ); + + shift!( + i64_shl, + Rq, + shl, + |a, b| (a as i64).wrapping_shl(b as _), + I64 + ); + shift!( + i64_shr_s, + Rq, + sar, + |a, b| (a as i64).wrapping_shr(b as _), + I64 + ); + shift!( + i64_shr_u, + Rq, + shr, + |a, b| (a as u64).wrapping_shr(b as _), + I64 + ); + shift!( + i64_rotl, + Rq, + rol, + |a, b| (a as u64).rotate_left(b as _), + I64 + ); + shift!( + i64_rotr, + Rq, + ror, + |a, b| (a as u64).rotate_right(b as _), + I64 + ); + + // TODO: Do this without emitting `mov` + fn cleanup_gprs(&mut self, gprs: impl Iterator<Item = GPR>) { + for gpr in gprs { + dynasm!(self.asm + ; pop Rq(gpr.rq().unwrap()) + ); + self.block_state.depth.free(1); + // DON'T MARK IT USED HERE! See comment in `full_div` + } + } + + int_div!( + i32_full_div_s, + i32_full_div_u, + i32_div_u, + i32_div_s, + i32_rem_u, + i32_rem_s, + imm_i32, + i32, + u32, + Rd, + DWORD + ); + int_div!( + i64_full_div_s, + i64_full_div_u, + i64_div_u, + i64_div_s, + i64_rem_u, + i64_rem_s, + imm_i64, + i64, + u64, + Rq, + QWORD + ); + + // TODO: With a proper SSE-like "Value" system we could do this way better (we wouldn't have + // to move `RAX`/`RDX` back afterwards). + fn full_div( + &mut self, + mut divisor: ValueLocation, + dividend: ValueLocation, + do_div: impl FnOnce(&mut Self, &mut ValueLocation) -> Result<(), Error>, + ) -> Result< + ( + ValueLocation, + ValueLocation, + impl Iterator<Item = GPR> + Clone + 'this, + ), + Error, + > { + // To stop `take_reg` from allocating either of these necessary registers + self.block_state.regs.mark_used(RAX); + self.block_state.regs.mark_used(RDX); + if divisor == ValueLocation::Reg(RAX) || divisor == ValueLocation::Reg(RDX) { + let new_reg = self.take_reg(GPRType::Rq).unwrap(); + self.copy_value(divisor, CCLoc::Reg(new_reg))?; + self.free_value(divisor)?; + + divisor = ValueLocation::Reg(new_reg); + } + self.block_state.regs.release(RAX)?; + self.block_state.regs.release(RDX)?; + + let saved_rax = if self.block_state.regs.is_free(RAX) { + None + } else { + dynasm!(self.asm + ; push rax + ); + self.block_state.depth.reserve(1); + // DON'T FREE THIS REGISTER HERE - since we don't + // remove it from the stack freeing the register + // here will cause `take_reg` to allocate it. + Some(()) + }; + + let saved_rdx = if self.block_state.regs.is_free(RDX) { + None + } else { + dynasm!(self.asm + ; push rdx + ); + self.block_state.depth.reserve(1); + // DON'T FREE THIS REGISTER HERE - since we don't + // remove it from the stack freeing the register + // here will cause `take_reg` to allocate it. + Some(()) + }; + + let saved = saved_rdx + .map(|_| RDX) + .into_iter() + .chain(saved_rax.map(|_| RAX)); + + self.copy_value(dividend, CCLoc::Reg(RAX))?; + self.block_state.regs.mark_used(RAX); + + self.free_value(dividend)?; + // To stop `take_reg` from allocating either of these necessary registers + self.block_state.regs.mark_used(RDX); + + do_div(self, &mut divisor)?; + self.free_value(divisor)?; + + if self.block_state.regs.is_free(RAX) { + return Err(Error::Microwasm("full_div: RAX is not free".to_string())); + } + if self.block_state.regs.is_free(RDX) { + return Err(Error::Microwasm("full_div: RDX is not free".to_string())); + } + + Ok((ValueLocation::Reg(RAX), ValueLocation::Reg(RDX), saved)) + } + + fn i32_full_div_u( + &mut self, + divisor: ValueLocation, + dividend: ValueLocation, + ) -> Result< + ( + ValueLocation, + ValueLocation, + impl Iterator<Item = GPR> + Clone + 'this, + ), + Error, + > { + self.full_div(divisor, dividend, |this, divisor| match divisor { + ValueLocation::Stack(offset) => { + let offset = this.adjusted_offset(*offset); + dynasm!(this.asm + ; xor edx, edx + ; div DWORD [rsp + offset] + ); + Ok(()) + } + ValueLocation::Immediate(_) | ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let r = match this.put_into_register(I32, divisor) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(this.asm + ; xor edx, edx + ; div Rd(r.rq().unwrap()) + ); + Ok(()) + } + }) + } + + fn i32_full_div_s( + &mut self, + divisor: ValueLocation, + dividend: ValueLocation, + ) -> Result< + ( + ValueLocation, + ValueLocation, + impl Iterator<Item = GPR> + Clone + 'this, + ), + Error, + > { + self.full_div(divisor, dividend, |this, divisor| match divisor { + ValueLocation::Stack(offset) => { + let offset = this.adjusted_offset(*offset); + dynasm!(this.asm + ; cdq + ; idiv DWORD [rsp + offset] + ); + Ok(()) + } + ValueLocation::Immediate(_) | ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let r = match this.put_into_register(I32, divisor) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(this.asm + ; cdq + ; idiv Rd(r.rq().unwrap()) + ); + Ok(()) + } + }) + } + + fn i64_full_div_u( + &mut self, + divisor: ValueLocation, + dividend: ValueLocation, + ) -> Result< + ( + ValueLocation, + ValueLocation, + impl Iterator<Item = GPR> + Clone + 'this, + ), + Error, + > { + self.full_div(divisor, dividend, |this, divisor| match divisor { + ValueLocation::Stack(offset) => { + let offset = this.adjusted_offset(*offset); + dynasm!(this.asm + ; xor rdx, rdx + ; div QWORD [rsp + offset] + ); + Ok(()) + } + ValueLocation::Immediate(_) | ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let r = match this.put_into_register(I64, divisor) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + dynasm!(this.asm + ; xor rdx, rdx + ; div Rq(r.rq().unwrap()) + ); + Ok(()) + } + }) + } + + fn i64_full_div_s( + &mut self, + divisor: ValueLocation, + dividend: ValueLocation, + ) -> Result< + ( + ValueLocation, + ValueLocation, + impl Iterator<Item = GPR> + Clone + 'this, + ), + Error, + > { + self.full_div(divisor, dividend, |this, divisor| match divisor { + ValueLocation::Stack(offset) => { + let offset = this.adjusted_offset(*offset); + dynasm!(this.asm + ; cqo + ; idiv QWORD [rsp + offset] + ); + Ok(()) + } + ValueLocation::Immediate(_) | ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let r = match this.put_into_register(I64, divisor) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(this.asm + ; cqo + ; idiv Rq(r.rq().unwrap()) + ); + Ok(()) + } + }) + } + + // `i32_mul` needs to be separate because the immediate form of the instruction + // has a different syntax to the immediate form of the other instructions. + pub fn i32_mul(&mut self) -> Result<(), Error> { + let right = self.pop()?; + let left = self.pop()?; + + if let Some(right) = right.immediate() { + if let Some(left) = left.immediate() { + self.push(ValueLocation::Immediate( + i32::wrapping_mul(right.as_i32().unwrap(), left.as_i32().unwrap()).into(), + ))?; + return Ok(()); + } + } + + let (mut left, mut right) = match left { + ValueLocation::Reg(_) => (left, right), + _ => { + if right.immediate().is_some() { + (left, right) + } else { + (right, left) + } + } + }; + + let out = match right { + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I32, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let lreg = match self.put_into_temp_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rd(lreg.rq().unwrap()), Rd(rreg.rq().unwrap()) + ); + left + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + let lreg = match self.put_into_temp_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rd(lreg.rq().unwrap()), [rsp + offset] + ); + left + } + ValueLocation::Immediate(i) => { + let lreg = match self.put_into_register(I32, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + let new_reg = self.take_reg(I32).unwrap(); + dynasm!(self.asm + ; imul Rd(new_reg.rq().unwrap()), Rd(lreg.rq().unwrap()), i.as_i32().unwrap() + ); + self.free_value(left)?; + ValueLocation::Reg(new_reg) + } + }; + + self.push(out)?; + self.free_value(right)?; + Ok(()) + } + + // `i64_mul` needs to be separate because the immediate form of the instruction + // has a different syntax to the immediate form of the other instructions. + pub fn i64_mul(&mut self) -> Result<(), Error> { + let right = self.pop()?; + let left = self.pop()?; + + if let Some(right) = right.immediate() { + if let Some(left) = left.immediate() { + self.push(ValueLocation::Immediate( + i64::wrapping_mul(right.as_i64().unwrap(), left.as_i64().unwrap()).into(), + ))?; + return Ok(()); + } + } + + let (mut left, mut right) = match left { + ValueLocation::Reg(_) => (left, right), + _ => { + if right.immediate().is_some() { + (left, right) + } else { + (right, left) + } + } + }; + + let out = match right { + ValueLocation::Reg(_) | ValueLocation::Cond(_) => { + let rreg = match self.put_into_register(I64, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let lreg = match self.put_into_temp_register(I64, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rq(lreg.rq().unwrap()), Rq(rreg.rq().unwrap()) + ); + left + } + ValueLocation::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + let lreg = match self.put_into_temp_register(I64, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rq(lreg.rq().unwrap()), [rsp + offset] + ); + left + } + ValueLocation::Immediate(i) => { + let i = i.as_i64().unwrap(); + if let Ok(i) = i.try_into() { + let new_reg = self.take_reg(I64).unwrap(); + + let lreg = match self.put_into_register(I64, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rq(new_reg.rq().unwrap()), Rq(lreg.rq().unwrap()), i + ); + + self.free_value(left)?; + + ValueLocation::Reg(new_reg) + } else { + let rreg = match self.put_into_register(I64, &mut right) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + let lreg = match self.put_into_temp_register(I64, &mut left) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + dynasm!(self.asm + ; imul Rq(lreg.rq().unwrap()), Rq(rreg.rq().unwrap()) + ); + left + } + } + }; + + self.push(out)?; + self.free_value(right)?; + Ok(()) + } + + fn cmov(&mut self, cond_code: CondCode, dst: GPR, src: CCLoc) { + match src { + CCLoc::Reg(reg) => match cond_code { + cc::EQUAL => { + dynasm!(self.asm + ; cmove Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::NOT_EQUAL => { + dynasm!(self.asm + ; cmovne Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::GE_U => { + dynasm!(self.asm + ; cmovae Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::LT_U => { + dynasm!(self.asm + ; cmovb Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::GT_U => { + dynasm!(self.asm + ; cmova Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::LE_U => { + dynasm!(self.asm + ; cmovbe Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::GE_S => { + dynasm!(self.asm + ; cmovge Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::LT_S => { + dynasm!(self.asm + ; cmovl Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::GT_S => { + dynasm!(self.asm + ; cmovg Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + cc::LE_S => { + dynasm!(self.asm + ; cmovle Rq(dst.rq().unwrap()), Rq(reg.rq().unwrap()) + ); + } + }, + CCLoc::Stack(offset) => { + let offset = self.adjusted_offset(offset); + + match cond_code { + cc::EQUAL => { + dynasm!(self.asm + ; cmove Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::NOT_EQUAL => { + dynasm!(self.asm + ; cmovne Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::GE_U => { + dynasm!(self.asm + ; cmovae Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::LT_U => { + dynasm!(self.asm + ; cmovb Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::GT_U => { + dynasm!(self.asm + ; cmova Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::LE_U => { + dynasm!(self.asm + ; cmovbe Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::GE_S => { + dynasm!(self.asm + ; cmovge Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::LT_S => { + dynasm!(self.asm + ; cmovl Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::GT_S => { + dynasm!(self.asm + ; cmovg Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + cc::LE_S => { + dynasm!(self.asm + ; cmovle Rq(dst.rq().unwrap()), [rsp + offset] + ); + } + } + } + } + } + + pub fn select(&mut self) -> Result<(), Error> { + let mut cond = self.pop()?; + let mut else_ = self.pop()?; + let mut then = self.pop()?; + + if let ValueLocation::Immediate(i) = cond { + if i.as_i32().unwrap() == 0 { + self.free_value(then)?; + self.push(else_)?; + } else { + self.free_value(else_)?; + self.push(then)?; + } + + return Ok(()); + } + + let cond_code = match cond { + ValueLocation::Cond(cc) => cc, + _ => { + let cond_reg = match self.put_into_register(I32, &mut cond) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + dynasm!(self.asm + ; test Rd(cond_reg.rq().unwrap()), Rd(cond_reg.rq().unwrap()) + ); + self.free_value(cond)?; + + cc::NOT_EQUAL + } + }; + + let else_ = if let ValueLocation::Stack(offset) = else_ { + CCLoc::Stack(offset) + } else { + let gpr = match self.put_into_register(I32, &mut else_) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + CCLoc::Reg(gpr) + }; + + let then = if let ValueLocation::Stack(offset) = then { + CCLoc::Stack(offset) + } else { + let gpr = match self.put_into_register(I32, &mut then) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + CCLoc::Reg(gpr) + }; + + let out_gpr = match (then, else_) { + (CCLoc::Reg(then_reg), else_) if self.block_state.regs.num_usages(then_reg) <= 1 => { + self.cmov(!cond_code, then_reg, else_); + self.free_value(else_.into())?; + + then_reg + } + (then, CCLoc::Reg(else_reg)) if self.block_state.regs.num_usages(else_reg) <= 1 => { + self.cmov(cond_code, else_reg, then); + self.free_value(then.into())?; + + else_reg + } + (then, else_) => { + let out = self.take_reg(GPRType::Rq).unwrap(); + self.copy_value(else_.into(), CCLoc::Reg(out))?; + self.cmov(cond_code, out, then); + + self.free_value(then.into())?; + self.free_value(else_.into())?; + + out + } + }; + + self.push(ValueLocation::Reg(out_gpr))?; + Ok(()) + } + + pub fn pick(&mut self, depth: u32) { + let idx = self.block_state.stack.len() - 1 - depth as usize; + let v = self.block_state.stack[idx]; + if let ValueLocation::Reg(r) = v { + self.block_state.regs.mark_used(r); + } + self.block_state.stack.push(v); + } + + pub fn const_(&mut self, imm: Value) -> Result<(), Error> { + self.push(ValueLocation::Immediate(imm))?; + Ok(()) + } + + fn relocated_function_call( + &mut self, + name: &cranelift_codegen::ir::ExternalName, + args: impl IntoIterator<Item = SignlessType>, + rets: impl IntoIterator<Item = SignlessType>, + preserve_vmctx: bool, + ) -> Result<(), Error> { + let locs = arg_locs(args)?; + + self.save_volatile(..locs.len())?; + + if preserve_vmctx { + dynasm!(self.asm + ; push Rq(VMCTX) + ); + self.block_state.depth.reserve(1); + } + + let depth = self.block_state.depth; + + self.pass_outgoing_args(&locs)?; + // 2 bytes for the 64-bit `mov` opcode + register ident, the rest is the immediate + self.reloc_sink.reloc_external( + (self.asm.offset().0 + - self.func_starts[self.current_function as usize] + .0 + .unwrap() + .0) as u32 + + 2, + binemit::Reloc::Abs8, + name, + 0, + ); + let temp = self.take_reg(I64).unwrap(); + dynasm!(self.asm + ; mov Rq(temp.rq().unwrap()), QWORD 0xDEAD_BEEF_DEAD_BEEF_u64 as i64 + ; call Rq(temp.rq().unwrap()) + ); + self.block_state.regs.release(temp)?; + + for i in locs { + self.free_value(i.into())?; + } + + self.push_function_returns(rets)?; + + if preserve_vmctx { + self.set_stack_depth(depth)?; + + dynasm!(self.asm + ; pop Rq(VMCTX) + ); + self.block_state.depth.free(1); + } + Ok(()) + } + + // TODO: Other memory indices + pub fn memory_size(&mut self) -> Result<(), Error> { + let memory_index = 0; + if let Some(defined_memory_index) = self.module_context.defined_memory_index(memory_index) { + self.push(ValueLocation::Immediate(defined_memory_index.into()))?; + self.relocated_function_call( + &magic::get_memory32_size_name(), + iter::once(I32), + iter::once(I32), + true, + )?; + } else { + self.push(ValueLocation::Immediate(memory_index.into()))?; + self.relocated_function_call( + &magic::get_imported_memory32_size_name(), + iter::once(I32), + iter::once(I32), + true, + )?; + } + Ok(()) + } + + // TODO: Other memory indices + pub fn memory_grow(&mut self) -> Result<(), Error> { + let memory_index = 0; + if let Some(defined_memory_index) = self.module_context.defined_memory_index(memory_index) { + self.push(ValueLocation::Immediate(defined_memory_index.into()))?; + self.relocated_function_call( + &magic::get_memory32_grow_name(), + iter::once(I32).chain(iter::once(I32)), + iter::once(I32), + true, + )?; + } else { + self.push(ValueLocation::Immediate(memory_index.into()))?; + self.relocated_function_call( + &magic::get_imported_memory32_grow_name(), + iter::once(I32).chain(iter::once(I32)), + iter::once(I32), + true, + )?; + } + Ok(()) + } + + // TODO: Use `ArrayVec`? + // TODO: This inefficiently duplicates registers but it's not really possible + // to double up stack space right now. + /// Saves volatile (i.e. caller-saved) registers before a function call, if they are used. + fn save_volatile(&mut self, _bounds: impl std::ops::RangeBounds<usize>) -> Result<(), Error> { + self.save_regs(SCRATCH_REGS, ..)?; + Ok(()) + } + + fn save_regs<I>( + &mut self, + regs: &I, + bounds: impl std::ops::RangeBounds<usize>, + ) -> Result<(), Error> + where + for<'a> &'a I: IntoIterator<Item = &'a GPR>, + I: ?Sized, + { + use std::ops::Bound::*; + + let mut stack = mem::replace(&mut self.block_state.stack, vec![]); + let (start, end) = ( + match bounds.end_bound() { + Unbounded => 0, + Included(v) => stack.len().saturating_sub(1 + v), + Excluded(v) => stack.len().saturating_sub(*v), + }, + match bounds.start_bound() { + Unbounded => stack.len(), + Included(v) => stack.len().saturating_sub(*v), + Excluded(v) => stack.len().saturating_sub(1 + v), + }, + ); + + let mut slice = &mut stack[start..end]; + + while let Some((first, rest)) = slice.split_first_mut() { + if let ValueLocation::Reg(vreg) = *first { + if regs.into_iter().any(|r| *r == vreg) { + let old = *first; + *first = self.push_physical(old)?; + for val in &mut *rest { + if *val == old { + self.free_value(*val)?; + *val = *first; + } + } + } + } + + slice = rest; + } + + mem::replace(&mut self.block_state.stack, stack); + Ok(()) + } + + /// Write the arguments to the callee to the registers and the stack using the SystemV + /// calling convention. + fn pass_outgoing_args(&mut self, out_locs: &[CCLoc]) -> Result<(), Error> { + // TODO: Do alignment here + let total_stack_space = out_locs + .iter() + .flat_map(|&l| { + if let CCLoc::Stack(offset) = l { + if offset > 0 { + Some(offset as u32) + } else { + None + } + } else { + None + } + }) + .max() + .unwrap_or(0); + let mut depth = self.block_state.depth.0 + total_stack_space; + + if depth & 1 != 0 { + self.set_stack_depth(StackDepth(self.block_state.depth.0 + 1))?; + depth += 1; + } + + let mut pending = Vec::<(ValueLocation, CCLoc)>::with_capacity(out_locs.len()); + + for &loc in out_locs.iter().rev() { + let val = self.pop()?; + + pending.push((val, loc)); + } + + while !pending.is_empty() { + let start_len = pending.len(); + + for (src, dst) in mem::replace(&mut pending, vec![]) { + if src != ValueLocation::from(dst) { + if let CCLoc::Reg(r) = dst { + if !self.block_state.regs.is_free(r) { + pending.push((src, dst)); + continue; + } + + self.block_state.regs.mark_used(r); + } + + self.copy_value(src, dst)?; + self.free_value(src)?; + } + } + + if pending.len() == start_len { + let src = match pending + .iter() + .filter_map(|(src, _)| { + if let ValueLocation::Reg(reg) = src { + Some(reg) + } else { + None + } + }) + .next() + { + None => { + return Err(Error::Microwasm( + "Programmer error: We shouldn't need to push \ + intermediate args if we don't have any argument sources in registers" + .to_string(), + )) + } + Some(val) => *val, + }; + let new_src = self.push_physical(ValueLocation::Reg(src))?; + for (old_src, _) in pending.iter_mut() { + if *old_src == ValueLocation::Reg(src) { + *old_src = new_src; + } + } + } + } + + self.set_stack_depth(StackDepth(depth))?; + Ok(()) + } + + fn push_function_returns( + &mut self, + returns: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + for loc in ret_locs(returns)? { + if let CCLoc::Reg(reg) = loc { + self.block_state.regs.mark_used(reg); + } + + self.push(loc.into())?; + } + Ok(()) + } + + pub fn call_indirect( + &mut self, + type_id: u32, + arg_types: impl IntoIterator<Item = SignlessType>, + return_types: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + let locs = arg_locs(arg_types)?; + + for &loc in &locs { + if let CCLoc::Reg(r) = loc { + self.block_state.regs.mark_used(r); + } + } + + let mut callee = self.pop()?; + let callee_reg = match self.put_into_temp_register(I32, &mut callee) { + Err(e) => return Err(e), + Ok(o) => o.unwrap(), + }; + + for &loc in &locs { + if let CCLoc::Reg(r) = loc { + self.block_state.regs.release(r)?; + } + } + + self.save_volatile(..locs.len())?; + dynasm!(self.asm + ; push Rq(VMCTX) + ); + self.block_state.depth.reserve(1); + let depth = self.block_state.depth; + + self.pass_outgoing_args(&locs)?; + + let fail = self.trap_label().0; + let table_index = 0; + let reg_offset = self + .module_context + .defined_table_index(table_index) + .map(|index| { + ( + None, + self.module_context.vmctx_vmtable_definition(index) as i32, + ) + }); + + let vmctx = GPR::Rq(VMCTX); + let (reg, offset) = reg_offset.unwrap_or_else(|| { + let reg = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; mov Rq(reg.rq().unwrap()), [ + Rq(VMCTX) + self.module_context.vmctx_vmtable_import_from(table_index) as i32 + ] + ); + + (Some(reg), 0) + }); + + let temp0 = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; cmp Rd(callee_reg.rq().unwrap()), [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + offset + + self.module_context.vmtable_definition_current_elements() as i32 + ] + ; jae =>fail + ; imul + Rd(callee_reg.rq().unwrap()), + Rd(callee_reg.rq().unwrap()), + self.module_context.size_of_vmcaller_checked_anyfunc() as i32 + ; mov Rq(temp0.rq().unwrap()), [ + Rq(reg.unwrap_or(vmctx).rq().unwrap()) + + offset + + self.module_context.vmtable_definition_base() as i32 + ] + ); + + if let Some(reg) = reg { + self.block_state.regs.release(reg)?; + } + + let temp1 = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; mov Rd(temp1.rq().unwrap()), [ + Rq(VMCTX) + + self.module_context + .vmctx_vmshared_signature_id(type_id) as i32 + ] + ; cmp DWORD [ + Rq(temp0.rq().unwrap()) + + Rq(callee_reg.rq().unwrap()) + + self.module_context.vmcaller_checked_anyfunc_type_index() as i32 + ], Rd(temp1.rq().unwrap()) + ; jne =>fail + ; mov Rq(VMCTX), [ + Rq(temp0.rq().unwrap()) + + Rq(callee_reg.rq().unwrap()) + + self.module_context.vmcaller_checked_anyfunc_vmctx() as i32 + ] + ; call QWORD [ + Rq(temp0.rq().unwrap()) + + Rq(callee_reg.rq().unwrap()) + + self.module_context.vmcaller_checked_anyfunc_func_ptr() as i32 + ] + ); + + self.block_state.regs.release(temp0)?; + self.block_state.regs.release(temp1)?; + self.free_value(callee)?; + + for i in locs { + self.free_value(i.into())?; + } + + self.push_function_returns(return_types)?; + + self.set_stack_depth(depth)?; + dynasm!(self.asm + ; pop Rq(VMCTX) + ); + self.block_state.depth.free(1); + Ok(()) + } + + pub fn swap(&mut self, depth: u32) { + let last = self.block_state.stack.len() - 1; + self.block_state.stack.swap(last, last - depth as usize); + } + + /// Call a function with the given index + pub fn call_direct( + &mut self, + index: u32, + arg_types: impl IntoIterator<Item = SignlessType>, + return_types: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + self.relocated_function_call( + &ir::ExternalName::user(0, index), + arg_types, + return_types, + false, + )?; + Ok(()) + } + + /// Call a function with the given index + pub fn call_direct_self( + &mut self, + defined_index: u32, + arg_types: impl IntoIterator<Item = SignlessType>, + return_types: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + let locs = arg_locs(arg_types)?; + + self.save_volatile(..locs.len())?; + + let (_, label) = self.func_starts[defined_index as usize]; + + self.pass_outgoing_args(&locs)?; + dynasm!(self.asm + ; call =>label + ); + + for i in locs { + self.free_value(i.into())?; + } + + self.push_function_returns(return_types)?; + Ok(()) + } + + /// Call a function with the given index + pub fn call_direct_imported( + &mut self, + index: u32, + arg_types: impl IntoIterator<Item = SignlessType>, + return_types: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + let locs = arg_locs(arg_types)?; + + dynasm!(self.asm + ; push Rq(VMCTX) + ); + self.block_state.depth.reserve(1); + let depth = self.block_state.depth; + + self.save_volatile(..locs.len())?; + self.pass_outgoing_args(&locs)?; + + let callee = self.take_reg(I64).unwrap(); + + dynasm!(self.asm + ; mov Rq(callee.rq().unwrap()), [ + Rq(VMCTX) + self.module_context.vmctx_vmfunction_import_body(index) as i32 + ] + ; mov Rq(VMCTX), [ + Rq(VMCTX) + self.module_context.vmctx_vmfunction_import_vmctx(index) as i32 + ] + ; call Rq(callee.rq().unwrap()) + ); + + self.block_state.regs.release(callee)?; + + for i in locs { + self.free_value(i.into())?; + } + + self.push_function_returns(return_types)?; + + self.set_stack_depth(depth)?; + dynasm!(self.asm + ; pop Rq(VMCTX) + ); + self.block_state.depth.free(1); + Ok(()) + } + + // TODO: Reserve space to store RBX, RBP, and R12..R15 so we can use them + // as scratch registers + /// Writes the function prologue and stores the arguments as locals + pub fn start_function( + &mut self, + params: impl IntoIterator<Item = SignlessType>, + ) -> Result<(), Error> { + let i_locs = arg_locs(params)?; + let locs = Vec::from_iter(i_locs); + + self.apply_cc(&BlockCallingConvention::function_start(locs))?; + Ok(()) + } + + pub fn ret(&mut self) { + dynasm!(self.asm + ; ret + ); + } + + pub fn epilogue(&mut self) {} + + pub fn trap(&mut self) { + let trap_label = self.trap_label(); + dynasm!(self.asm + ; jmp =>trap_label.0 + ); + } + + pub fn trap_label(&mut self) -> Label { + self.label(|asm: &mut Assembler| { + dynasm!(asm + ; ud2 + ); + }) + } + + pub fn ret_label(&mut self) -> Label { + self.label(|asm: &mut Assembler| { + dynasm!(asm + ; ret + ); + }) + } + + fn label<F>(&mut self, fun: F) -> Label + where + F: IntoLabel, + { + self.aligned_label(1, fun) + } + + fn aligned_label<F>(&mut self, align: u32, fun: F) -> Label + where + F: IntoLabel, + { + let key = fun.key(); + if let Some((label, _, _)) = self.labels.get(&(align, key)) { + return *label; + } + + let label = self.create_label(); + self.labels + .insert((align, key), (label, align, Some(fun.callback()))); + + label + } + + fn target_to_label(&mut self, target: BrTarget<Label>) -> Label { + match target { + BrTarget::Label(label) => label, + BrTarget::Return => self.ret_label(), + } + } +} + +trait IntoLabel { + fn key(&self) -> Either<TypeId, (LabelValue, Option<LabelValue>)>; + fn callback(self) -> Box<dyn FnMut(&mut Assembler)>; +} + +impl<F> IntoLabel for F +where + F: FnMut(&mut Assembler) + Any, +{ + fn key(&self) -> Either<TypeId, (LabelValue, Option<LabelValue>)> { + Either::Left(TypeId::of::<Self>()) + } + + fn callback(self) -> Box<dyn FnMut(&mut Assembler)> { + Box::new(self) + } +} + +fn const_value(val: LabelValue) -> impl FnMut(&mut Assembler) { + move |asm| match val { + LabelValue::I32(val) => dynasm!(asm + ; .dword val + ), + LabelValue::I64(val) => dynasm!(asm + ; .qword val + ), + } +} + +fn const_values(a: LabelValue, b: LabelValue) -> impl FnMut(&mut Assembler) { + move |asm| { + match a { + LabelValue::I32(val) => dynasm!(asm + ; .dword val + ), + LabelValue::I64(val) => dynasm!(asm + ; .qword val + ), + } + + match b { + LabelValue::I32(val) => dynasm!(asm + ; .dword val + ), + LabelValue::I64(val) => dynasm!(asm + ; .qword val + ), + } + } +} + +impl IntoLabel for LabelValue { + fn key(&self) -> Either<TypeId, (LabelValue, Option<LabelValue>)> { + Either::Right((*self, None)) + } + fn callback(self) -> Box<dyn FnMut(&mut Assembler)> { + Box::new(const_value(self)) + } +} + +impl IntoLabel for (LabelValue, LabelValue) { + fn key(&self) -> Either<TypeId, (LabelValue, Option<LabelValue>)> { + Either::Right((self.0, Some(self.1))) + } + fn callback(self) -> Box<dyn FnMut(&mut Assembler)> { + Box::new(const_values(self.0, self.1)) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +
+use capstone::prelude::*; +use dynasmrt::AssemblyOffset; +use std::error::Error; +use std::fmt::{Display, Write}; + +pub fn disassemble( + mem: &[u8], + mut ops: &[(AssemblyOffset, impl Display)], +) -> Result<(), Box<dyn Error>> { + let cs = Capstone::new() + .x86() + .mode(arch::x86::ArchMode::Mode64) + .build()?; + + println!("{} bytes:", mem.len()); + let insns = cs.disasm_all(&mem, 0x0)?; + for i in insns.iter() { + let mut line = String::new(); + + let address = i.address(); + + while let Some((offset, op)) = ops.first() { + if offset.0 as u64 <= address { + ops = &ops[1..]; + println!("{}", op); + } else { + break; + } + } + + write!(&mut line, "{:4x}:\t", i.address())?; + + let mut bytes_str = String::new(); + for b in i.bytes() { + write!(&mut bytes_str, "{:02x} ", b)?; + } + write!(&mut line, "{:24}\t", bytes_str)?; + + if let Some(s) = i.mnemonic() { + write!(&mut line, "{}\t", s)?; + } + + if let Some(s) = i.op_str() { + write!(&mut line, "{}", s)?; + } + + println!("{}", line); + } + + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +
+use capstone; +use thiserror::Error; +use wasmparser::BinaryReaderError; + +#[derive(Error, PartialEq, Eq, Clone, Debug)] +pub enum Error { + #[error("Disassembler error: {0}")] + Disassembler(String), + + #[error("Assembler error: {0}")] + Assembler(String), + + #[error("Input error: {0}")] + Input(String), + + #[error("Microwasm error: {0}")] + Microwasm(String), +} + +impl From<BinaryReaderError> for Error { + fn from(e: BinaryReaderError) -> Self { + Error::Input(format!("At wasm offset {}: {}", e.offset(), e.message())) + } +} + +impl From<capstone::Error> for Error { + fn from(e: capstone::Error) -> Self { + Error::Disassembler(e.to_string()) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +
+use crate::backend::{ + ret_locs, BlockCallingConvention, CodeGenSession, Context, Label, VirtualCallingConvention, +}; +#[cfg(debug_assertions)] +use crate::backend::{Registers, ValueLocation}; +use crate::error::Error; +use crate::microwasm::*; +use crate::module::{ModuleContext, SigType, Signature}; +use cranelift_codegen::binemit; +use dynasmrt::DynasmApi; +use either::{Either, Left, Right}; +#[cfg(debug_assertions)] +use more_asserts::assert_ge; +use multi_mut::HashMapMultiMut; +use std::{collections::HashMap, hash::Hash}; +use std::{fmt, mem}; + +#[derive(Debug)] +struct Block { + label: BrTarget<Label>, + calling_convention: Option<Either<BlockCallingConvention, VirtualCallingConvention>>, + params: u32, + // TODO: Is there a cleaner way to do this? `has_backwards_callers` should always be set if `is_next` + // is false, so we should probably use an `enum` here. + is_next: bool, + num_callers: Option<u32>, + actual_num_callers: u32, + has_backwards_callers: bool, +} + +impl Block { + fn should_serialize_args(&self) -> bool { + self.calling_convention.is_none() + && (self.num_callers != Some(1) || self.has_backwards_callers) + } +} + +const DISASSEMBLE: bool = false; + +pub fn translate_wasm<M>( + session: &mut CodeGenSession<M>, + reloc_sink: &mut dyn binemit::RelocSink, + func_idx: u32, + body: &wasmparser::FunctionBody, +) -> Result<(), Error> +where + M: ModuleContext, + for<'any> &'any M::Signature: Into<OpSig>, +{ + let ty = session.module_context.defined_func_type(func_idx); + + if DISASSEMBLE { + let microwasm_conv = MicrowasmConv::new( + session.module_context, + ty.params().iter().map(SigType::to_microwasm_type), + ty.returns().iter().map(SigType::to_microwasm_type), + body, + )?; + + let _ = crate::microwasm::dis( + std::io::stdout(), + func_idx, + microwasm_conv.flat_map(|ops| ops.unwrap()), + ); + } + + let microwasm_conv = MicrowasmConv::new( + session.module_context, + ty.params().iter().map(SigType::to_microwasm_type), + ty.returns().iter().map(SigType::to_microwasm_type), + body, + )?; + + let mut body = Vec::new(); + for i in microwasm_conv { + body.extend(i?); + } + + translate(session, reloc_sink, func_idx, body)?; + Ok(()) +} + +pub fn translate<M, I, L: Send + Sync + 'static>( + session: &mut CodeGenSession<M>, + reloc_sink: &mut dyn binemit::RelocSink, + func_idx: u32, + body: I, +) -> Result<(), Error> +where + M: ModuleContext, + I: IntoIterator<Item = Operator<L>>, + L: Hash + Clone + Eq, + BrTarget<L>: std::fmt::Display, +{ + fn drop_elements<T>(stack: &mut Vec<T>, depths: std::ops::RangeInclusive<u32>) { + let _ = (|| { + let start = stack + .len() + .checked_sub(1)? + .checked_sub(*depths.end() as usize)?; + let end = stack + .len() + .checked_sub(1)? + .checked_sub(*depths.start() as usize)?; + let real_range = start..=end; + + stack.drain(real_range); + + Some(()) + })(); + } + + let func_type = session.module_context.defined_func_type(func_idx); + let mut body = body.into_iter().peekable(); + + let module_context = &*session.module_context; + let mut op_offset_map = mem::replace(&mut session.op_offset_map, vec![]); + let ctx = &mut session.new_context(func_idx, reloc_sink); + op_offset_map.push(( + ctx.asm.offset(), + Box::new(format!("Function {}:", func_idx)), + )); + + let params = func_type + .params() + .iter() + .map(|t| t.to_microwasm_type()) + .collect::<Vec<_>>(); + + ctx.start_function(params.iter().cloned())?; + + let mut blocks = HashMap::<BrTarget<L>, Block>::new(); + + let num_returns = func_type.returns().len(); + + let loc = ret_locs(func_type.returns().iter().map(|t| t.to_microwasm_type()))?; + + blocks.insert( + BrTarget::Return, + Block { + label: BrTarget::Return, + params: num_returns as u32, + calling_convention: Some(Left(BlockCallingConvention::function_start(loc))), + is_next: false, + has_backwards_callers: false, + actual_num_callers: 0, + num_callers: None, + }, + ); + + while let Some(op) = body.next() { + if let Some(Operator::Label(label)) = body.peek() { + let block = match blocks.get_mut(&BrTarget::Label(label.clone())) { + None => { + return Err(Error::Microwasm( + "Label defined before being declared".to_string(), + )) + } + Some(o) => o, + }; + block.is_next = true; + } + + // `cfg` on blocks doesn't work in the compiler right now, so we have to write a dummy macro + #[cfg(debug_assertions)] + macro_rules! assertions { + () => { + if let Operator::Label(label) = &op { + let block = &blocks[&BrTarget::Label(label.clone())]; + let num_cc_params = block.calling_convention.as_ref().map(|cc| match cc { + Left(cc) => cc.arguments.len(), + Right(cc) => cc.stack.len(), + }); + if let Some(num_cc_params) = num_cc_params { + // we can use assert here bc we are in debug mode + assert_ge!(num_cc_params, block.params as usize); + } + } else { + let mut actual_regs = Registers::new(); + actual_regs.release_scratch_register()?; + for val in &ctx.block_state.stack { + if let ValueLocation::Reg(gpr) = val { + actual_regs.mark_used(*gpr); + } + } + // we can use assert here bc we are in debug mode + assert_eq!(actual_regs, ctx.block_state.regs); + } + }; + } + + #[cfg(not(debug_assertions))] + macro_rules! assertions { + () => {}; + } + + assertions!(); + + struct DisassemblyOpFormatter<Label>(Operator<Label>); + + impl<Label> fmt::Display for DisassemblyOpFormatter<Label> + where + Operator<Label>: fmt::Display, + { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.0 { + Operator::Label(_) => write!(f, "{}", self.0), + Operator::Block { .. } => write!(f, "{:5}\t{}", "", self.0), + _ => write!(f, "{:5}\t {}", "", self.0), + } + } + } + + op_offset_map.push(( + ctx.asm.offset(), + Box::new(DisassemblyOpFormatter(op.clone())), + )); + + match op { + Operator::Unreachable => { + ctx.trap(); + } + Operator::Label(label) => { + use std::collections::hash_map::Entry; + + if let Entry::Occupied(mut entry) = blocks.entry(BrTarget::Label(label.clone())) { + let has_backwards_callers = { + let block = entry.get_mut(); + + // TODO: Maybe we want to restrict Microwasm so that at least one of its callers + // must be before the label. In an ideal world the restriction would be that + // blocks without callers are illegal, but that's not reasonably possible for + // Microwasm generated from Wasm. + if block.actual_num_callers == 0 { + loop { + let done = match body.peek() { + Some(Operator::Label(_)) | None => true, + Some(_) => false, + }; + + if done { + break; + } + + let skipped = body.next(); + + // We still want to honour block definitions even in unreachable code + if let Some(Operator::Block { + label, + has_backwards_callers, + params, + num_callers, + }) = skipped + { + let asm_label = ctx.create_label(); + blocks.insert( + BrTarget::Label(label), + Block { + label: BrTarget::Label(asm_label), + params: params.len() as _, + calling_convention: None, + is_next: false, + has_backwards_callers, + actual_num_callers: 0, + num_callers, + }, + ); + } + } + + continue; + } + + block.is_next = false; + + // TODO: We can `take` this if it's a `Right` + match block.calling_convention.as_ref() { + Some(Left(cc)) => { + ctx.apply_cc(cc)?; + } + Some(Right(virt)) => { + ctx.set_state(virt.clone())?; + } + _ => { + if block.params as usize != ctx.block_state.stack.len() { + return Err(Error::Microwasm( + "Not enough block params on the stack".to_string(), + )); + } + } + } + + ctx.define_label(block.label.label().unwrap().clone()); + + block.has_backwards_callers + }; + + // To reduce memory overhead + if !has_backwards_callers { + entry.remove_entry(); + } + } else { + return Err(Error::Microwasm( + "Label defined before being declared".to_string(), + )); + } + } + Operator::Block { + label, + has_backwards_callers, + params, + num_callers, + } => { + let asm_label = ctx.create_label(); + blocks.insert( + BrTarget::Label(label), + Block { + label: BrTarget::Label(asm_label), + params: params.len() as _, + calling_convention: None, + is_next: false, + has_backwards_callers, + actual_num_callers: 0, + num_callers, + }, + ); + } + Operator::Br { target } => { + // TODO: We should add the block to the hashmap if we don't have it already + let block = blocks.get_mut(&target).unwrap(); + block.actual_num_callers += 1; + + let should_serialize_args = block.should_serialize_args(); + + match block { + Block { + is_next, + label: BrTarget::Label(l), + calling_convention, + .. + } => { + let cc = if should_serialize_args { + let block_conv = ctx.serialize_args(block.params)?; + *calling_convention = Some(Left(block_conv)); + None + } else { + calling_convention + .as_ref() + .map(Either::as_ref) + .and_then(Either::left) + }; + + if let Some(cc) = cc { + ctx.pass_block_args(cc)?; + } + + if !*is_next { + ctx.br(*l); + } + } + Block { + label: BrTarget::Return, + calling_convention: Some(Left(cc)), + .. + } => { + ctx.pass_block_args(cc)?; + ctx.ret(); + } + _ => return Err(Error::Microwasm("Br case unimplemented".to_string())), + } + } + Operator::BrIf { then, else_ } => { + let (then_block, else_block) = blocks.pair_mut(&then.target, &else_.target); + // TODO: If actual_num_callers == num_callers then we can remove this block from the hashmap. + // This frees memory and acts as a kind of verification that `num_callers` is set + // correctly. It doesn't help for loops and block ends generated from Wasm. + then_block.actual_num_callers += 1; + else_block.actual_num_callers += 1; + + let then_block_parts = (then_block.is_next, then_block.label); + let else_block_parts = (else_block.is_next, else_block.label); + + // TODO: The blocks should have compatible (one must be subset of other?) calling + // conventions or else at least one must have no calling convention. This + // should always be true for converting from WebAssembly AIUI. + let f = |ctx: &mut Context<_>| { + let then_block_should_serialize_args = then_block.should_serialize_args(); + let else_block_should_serialize_args = else_block.should_serialize_args(); + let max_params = then_block.params.max(else_block.params); + + match ( + (&mut then_block.calling_convention, &then.to_drop), + (&mut else_block.calling_convention, &else_.to_drop), + ) { + ((Some(Left(ref cc)), _), ref mut other @ (None, _)) + | (ref mut other @ (None, _), (Some(Left(ref cc)), _)) => { + let mut cc = ctx.serialize_block_args(cc, max_params)?; + if let Some(to_drop) = other.1 { + drop_elements(&mut cc.arguments, to_drop.clone()); + } + *other.0 = Some(Left(cc)); + Ok(()) + }, + ( + (ref mut then_cc @ None, then_to_drop), + (ref mut else_cc @ None, else_to_drop), + ) => { + let virt_cc = if !then_block_should_serialize_args + || !else_block_should_serialize_args + { + Some(ctx.virtual_calling_convention()) + } else { + None + }; + + let cc = if then_block_should_serialize_args + || else_block_should_serialize_args { let a = ctx.serialize_args(max_params)? ; Some(a) } else { None }; + + **then_cc = if then_block_should_serialize_args { + let mut cc = cc.clone().unwrap(); + if let Some(to_drop) = then_to_drop.clone() { + drop_elements(&mut cc.arguments, to_drop); + } + Some(Left(cc)) + } else { + let mut cc = virt_cc.clone().unwrap(); + if let Some(to_drop) = then_to_drop.clone() { + drop_elements(&mut cc.stack, to_drop); + } + Some(Right(cc)) + }; + **else_cc = if else_block_should_serialize_args { + let mut cc = cc.unwrap(); + if let Some(to_drop) = else_to_drop.clone() { + drop_elements(&mut cc.arguments, to_drop); + } + Some(Left(cc)) + } else { + let mut cc = virt_cc.unwrap(); + if let Some(to_drop) = else_to_drop.clone() { + drop_elements(&mut cc.stack, to_drop); + } + Some(Right(cc)) + }; + Ok(()) + }, + _ => Err(Error::Microwasm( + "unimplemented: Can't pass different params to different sides of `br_if` yet".to_string(), + )), + } + }; + + match (then_block_parts, else_block_parts) { + ((true, _), (false, else_)) => { + ctx.br_if_false(else_, f)?; + } + ((false, then), (true, _)) => { + ctx.br_if_true(then, f)?; + } + ((false, then), (false, else_)) => { + ctx.br_if_true(then, f)?; + ctx.br(else_); + } + other => { + return Err(Error::Microwasm(format!( + "br_if unimplemented case: {:#?}", + other + ))) + } + }; + } + Operator::BrTable(BrTable { targets, default }) => { + use itertools::Itertools; + + let (label, num_callers, params) = { + let def = &blocks[&default.target]; + ( + if def.is_next { None } else { Some(def.label) }, + def.num_callers, + def.params + + default + .to_drop + .as_ref() + .map(|t| t.clone().count()) + .unwrap_or_default() as u32, + ) + }; + + let target_labels = targets + .iter() + .map(|target| { + let block = &blocks[&target.target]; + if block.is_next { + None + } else { + Some(block.label) + } + }) + .collect::<Vec<_>>(); + + ctx.br_table(target_labels, label, |ctx| { + let mut cc = None; + let mut max_params = params; + let mut max_num_callers = num_callers; + + for target in targets.iter().chain(std::iter::once(&default)).unique() { + let block = blocks.get_mut(&target.target).unwrap(); + block.actual_num_callers += 1; + + if block.calling_convention.is_some() { + let new_cc = block.calling_convention.clone(); + + if !(cc.is_none() || cc == new_cc) { + return Err(Error::Microwasm( + "Can't pass different params to different elements of `br_table` yet" + .to_string())); + } + cc = new_cc; + } + + if let Some(max) = max_num_callers { + max_num_callers = block.num_callers.map(|n| max.max(n)); + } + + max_params = max_params.max( + block.params + + target + .to_drop + .as_ref() + .map(|t| t.clone().count()) + .unwrap_or_default() as u32, + ); + } + + let temp: Result< + Either<BlockCallingConvention, VirtualCallingConvention>, + Error, + > = cc + .map(|cc| match cc { + Left(cc) => { + let tmp = ctx.serialize_block_args(&cc, max_params)?; + Ok(Left(tmp)) + } + Right(cc) => Ok(Right(cc)), + }) + .unwrap_or_else(|| { + if max_num_callers.map(|callers| callers <= 1).unwrap_or(false) { + Ok(Right(ctx.virtual_calling_convention())) + } else { + let tmp = ctx.serialize_args(max_params)?; + Ok(Left(tmp)) + } + }); + let cc = match temp.unwrap() { + Right(rr) => Right(rr), + Left(l) => Left(l), + }; + + for target in targets.iter().chain(std::iter::once(&default)).unique() { + let block = blocks.get_mut(&target.target).unwrap(); + let mut cc = cc.clone(); + if let Some(to_drop) = target.to_drop.clone() { + match &mut cc { + Left(cc) => drop_elements(&mut cc.arguments, to_drop), + Right(cc) => drop_elements(&mut cc.stack, to_drop), + } + } + block.calling_convention = Some(cc); + } + Ok(()) + })?; + } + Operator::Swap(depth) => ctx.swap(depth), + Operator::Pick(depth) => ctx.pick(depth), + Operator::Eq(I32) => ctx.i32_eq()?, + Operator::Eqz(Size::_32) => ctx.i32_eqz()?, + Operator::Ne(I32) => ctx.i32_neq()?, + Operator::Lt(SI32) => ctx.i32_lt_s()?, + Operator::Le(SI32) => ctx.i32_le_s()?, + Operator::Gt(SI32) => ctx.i32_gt_s()?, + Operator::Ge(SI32) => ctx.i32_ge_s()?, + Operator::Lt(SU32) => ctx.i32_lt_u()?, + Operator::Le(SU32) => ctx.i32_le_u()?, + Operator::Gt(SU32) => ctx.i32_gt_u()?, + Operator::Ge(SU32) => ctx.i32_ge_u()?, + Operator::Add(I32) => ctx.i32_add()?, + Operator::Sub(I32) => ctx.i32_sub()?, + Operator::And(Size::_32) => ctx.i32_and()?, + Operator::Or(Size::_32) => ctx.i32_or()?, + Operator::Xor(Size::_32) => ctx.i32_xor()?, + Operator::Mul(I32) => ctx.i32_mul()?, + Operator::Div(SU32) => ctx.i32_div_u()?, + Operator::Div(SI32) => ctx.i32_div_s()?, + Operator::Rem(sint::I32) => ctx.i32_rem_s()?, + Operator::Rem(sint::U32) => ctx.i32_rem_u()?, + Operator::Shl(Size::_32) => ctx.i32_shl()?, + Operator::Shr(sint::I32) => ctx.i32_shr_s()?, + Operator::Shr(sint::U32) => ctx.i32_shr_u()?, + Operator::Rotl(Size::_32) => ctx.i32_rotl()?, + Operator::Rotr(Size::_32) => ctx.i32_rotr()?, + Operator::Clz(Size::_32) => ctx.i32_clz()?, + Operator::Ctz(Size::_32) => ctx.i32_ctz()?, + Operator::Popcnt(Size::_32) => ctx.i32_popcnt()?, + Operator::Eq(I64) => ctx.i64_eq()?, + Operator::Eqz(Size::_64) => ctx.i64_eqz()?, + Operator::Ne(I64) => ctx.i64_neq()?, + Operator::Lt(SI64) => ctx.i64_lt_s()?, + Operator::Le(SI64) => ctx.i64_le_s()?, + Operator::Gt(SI64) => ctx.i64_gt_s()?, + Operator::Ge(SI64) => ctx.i64_ge_s()?, + Operator::Lt(SU64) => ctx.i64_lt_u()?, + Operator::Le(SU64) => ctx.i64_le_u()?, + Operator::Gt(SU64) => ctx.i64_gt_u()?, + Operator::Ge(SU64) => ctx.i64_ge_u()?, + Operator::Add(I64) => ctx.i64_add()?, + Operator::Sub(I64) => ctx.i64_sub()?, + Operator::And(Size::_64) => ctx.i64_and()?, + Operator::Or(Size::_64) => ctx.i64_or()?, + Operator::Xor(Size::_64) => ctx.i64_xor()?, + Operator::Mul(I64) => ctx.i64_mul()?, + Operator::Div(SU64) => ctx.i64_div_u()?, + Operator::Div(SI64) => ctx.i64_div_s()?, + Operator::Rem(sint::I64) => ctx.i64_rem_s()?, + Operator::Rem(sint::U64) => ctx.i64_rem_u()?, + Operator::Shl(Size::_64) => ctx.i64_shl()?, + Operator::Shr(sint::I64) => ctx.i64_shr_s()?, + Operator::Shr(sint::U64) => ctx.i64_shr_u()?, + Operator::Rotl(Size::_64) => ctx.i64_rotl()?, + Operator::Rotr(Size::_64) => ctx.i64_rotr()?, + Operator::Clz(Size::_64) => ctx.i64_clz()?, + Operator::Ctz(Size::_64) => ctx.i64_ctz()?, + Operator::Popcnt(Size::_64) => ctx.i64_popcnt()?, + Operator::Add(F32) => ctx.f32_add()?, + Operator::Mul(F32) => ctx.f32_mul()?, + Operator::Sub(F32) => ctx.f32_sub()?, + Operator::Div(SF32) => ctx.f32_div()?, + Operator::Min(Size::_32) => ctx.f32_min()?, + Operator::Max(Size::_32) => ctx.f32_max()?, + Operator::Copysign(Size::_32) => ctx.f32_copysign()?, + Operator::Sqrt(Size::_32) => ctx.f32_sqrt()?, + Operator::Neg(Size::_32) => ctx.f32_neg()?, + Operator::Abs(Size::_32) => ctx.f32_abs()?, + Operator::Floor(Size::_32) => ctx.f32_floor()?, + Operator::Ceil(Size::_32) => ctx.f32_ceil()?, + Operator::Nearest(Size::_32) => ctx.f32_nearest()?, + Operator::Trunc(Size::_32) => ctx.f32_trunc()?, + Operator::Eq(F32) => ctx.f32_eq()?, + Operator::Ne(F32) => ctx.f32_ne()?, + Operator::Gt(SF32) => ctx.f32_gt()?, + Operator::Ge(SF32) => ctx.f32_ge()?, + Operator::Lt(SF32) => ctx.f32_lt()?, + Operator::Le(SF32) => ctx.f32_le()?, + Operator::Add(F64) => ctx.f64_add()?, + Operator::Mul(F64) => ctx.f64_mul()?, + Operator::Sub(F64) => ctx.f64_sub()?, + Operator::Div(SF64) => ctx.f64_div()?, + Operator::Min(Size::_64) => ctx.f64_min()?, + Operator::Max(Size::_64) => ctx.f64_max()?, + Operator::Copysign(Size::_64) => ctx.f64_copysign()?, + Operator::Sqrt(Size::_64) => ctx.f64_sqrt()?, + Operator::Neg(Size::_64) => ctx.f64_neg()?, + Operator::Abs(Size::_64) => ctx.f64_abs()?, + Operator::Floor(Size::_64) => ctx.f64_floor()?, + Operator::Ceil(Size::_64) => ctx.f64_ceil()?, + Operator::Nearest(Size::_64) => ctx.f64_nearest()?, + Operator::Trunc(Size::_64) => ctx.f64_trunc()?, + Operator::Eq(F64) => ctx.f64_eq()?, + Operator::Ne(F64) => ctx.f64_ne()?, + Operator::Gt(SF64) => ctx.f64_gt()?, + Operator::Ge(SF64) => ctx.f64_ge()?, + Operator::Lt(SF64) => ctx.f64_lt()?, + Operator::Le(SF64) => ctx.f64_le()?, + Operator::Drop(range) => ctx.drop(range)?, + Operator::Const(val) => ctx.const_(val)?, + Operator::I32WrapFromI64 => ctx.i32_wrap_from_i64()?, + Operator::I32ReinterpretFromF32 => ctx.i32_reinterpret_from_f32()?, + Operator::I64ReinterpretFromF64 => ctx.i64_reinterpret_from_f64()?, + Operator::F32ReinterpretFromI32 => ctx.f32_reinterpret_from_i32()?, + Operator::F64ReinterpretFromI64 => ctx.f64_reinterpret_from_i64()?, + Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::I32, + } => { + ctx.i32_truncate_f32_s()?; + } + Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::U32, + } => { + ctx.i32_truncate_f32_u()?; + } + Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::I32, + } => { + ctx.i32_truncate_f64_s()?; + } + Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::U32, + } => { + ctx.i32_truncate_f64_u()?; + } + Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::I64, + } => { + ctx.i64_truncate_f32_s()?; + } + Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::U64, + } => { + ctx.i64_truncate_f32_u()?; + } + Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::I64, + } => { + ctx.i64_truncate_f64_s()?; + } + Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::U64, + } => { + ctx.i64_truncate_f64_u()?; + } + Operator::Extend { + sign: Signedness::Unsigned, + } => ctx.i32_extend_u()?, + Operator::Extend { + sign: Signedness::Signed, + } => ctx.i32_extend_s()?, + Operator::FConvertFromI { + input_ty: sint::I32, + output_ty: Size::_32, + } => ctx.f32_convert_from_i32_s()?, + Operator::FConvertFromI { + input_ty: sint::I32, + output_ty: Size::_64, + } => ctx.f64_convert_from_i32_s()?, + Operator::FConvertFromI { + input_ty: sint::I64, + output_ty: Size::_32, + } => ctx.f32_convert_from_i64_s()?, + Operator::FConvertFromI { + input_ty: sint::I64, + output_ty: Size::_64, + } => ctx.f64_convert_from_i64_s()?, + Operator::FConvertFromI { + input_ty: sint::U32, + output_ty: Size::_32, + } => ctx.f32_convert_from_i32_u()?, + Operator::FConvertFromI { + input_ty: sint::U32, + output_ty: Size::_64, + } => ctx.f64_convert_from_i32_u()?, + Operator::FConvertFromI { + input_ty: sint::U64, + output_ty: Size::_32, + } => ctx.f32_convert_from_i64_u()?, + Operator::FConvertFromI { + input_ty: sint::U64, + output_ty: Size::_64, + } => ctx.f64_convert_from_i64_u()?, + Operator::F64PromoteFromF32 => ctx.f64_from_f32()?, + Operator::F32DemoteFromF64 => ctx.f32_from_f64()?, + Operator::Load8 { + ty: sint::U32, + memarg, + } => ctx.i32_load8_u(memarg.offset)?, + Operator::Load16 { + ty: sint::U32, + memarg, + } => ctx.i32_load16_u(memarg.offset)?, + Operator::Load8 { + ty: sint::I32, + memarg, + } => ctx.i32_load8_s(memarg.offset)?, + Operator::Load16 { + ty: sint::I32, + memarg, + } => ctx.i32_load16_s(memarg.offset)?, + Operator::Load8 { + ty: sint::U64, + memarg, + } => ctx.i64_load8_u(memarg.offset)?, + Operator::Load16 { + ty: sint::U64, + memarg, + } => ctx.i64_load16_u(memarg.offset)?, + Operator::Load8 { + ty: sint::I64, + memarg, + } => ctx.i64_load8_s(memarg.offset)?, + Operator::Load16 { + ty: sint::I64, + memarg, + } => ctx.i64_load16_s(memarg.offset)?, + Operator::Load32 { + sign: Signedness::Unsigned, + memarg, + } => ctx.i64_load32_u(memarg.offset)?, + Operator::Load32 { + sign: Signedness::Signed, + memarg, + } => ctx.i64_load32_s(memarg.offset)?, + Operator::Load { ty: I32, memarg } => ctx.i32_load(memarg.offset)?, + Operator::Load { ty: F32, memarg } => ctx.f32_load(memarg.offset)?, + Operator::Load { ty: I64, memarg } => ctx.i64_load(memarg.offset)?, + Operator::Load { ty: F64, memarg } => ctx.f64_load(memarg.offset)?, + Operator::Store8 { memarg, .. } => ctx.store8(memarg.offset)?, + Operator::Store16 { memarg, .. } => ctx.store16(memarg.offset)?, + Operator::Store32 { memarg } + | Operator::Store { ty: I32, memarg } + | Operator::Store { ty: F32, memarg } => ctx.store32(memarg.offset)?, + Operator::Store { ty: I64, memarg } | Operator::Store { ty: F64, memarg } => { + ctx.store64(memarg.offset)? + } + Operator::GlobalGet(idx) => ctx.get_global(idx)?, + Operator::GlobalSet(idx) => ctx.set_global(idx)?, + Operator::Select => { + ctx.select()?; + } + Operator::MemorySize { .. } => { + ctx.memory_size()?; + } + Operator::MemoryGrow { .. } => { + ctx.memory_grow()?; + } + Operator::Call { function_index } => { + let callee_ty = module_context.func_type(function_index); + + if let Some(defined_index) = module_context.defined_func_index(function_index) { + if function_index == func_idx { + ctx.call_direct_self( + defined_index, + callee_ty.params().iter().map(|t| t.to_microwasm_type()), + callee_ty.returns().iter().map(|t| t.to_microwasm_type()), + )?; + } else { + ctx.call_direct( + function_index, + callee_ty.params().iter().map(|t| t.to_microwasm_type()), + callee_ty.returns().iter().map(|t| t.to_microwasm_type()), + )?; + } + } else { + ctx.call_direct_imported( + function_index, + callee_ty.params().iter().map(|t| t.to_microwasm_type()), + callee_ty.returns().iter().map(|t| t.to_microwasm_type()), + )?; + } + } + Operator::CallIndirect { + type_index, + table_index, + } => { + if table_index != 0 { + return Err(Error::Microwasm("table_index not equal to 0".to_string())); + } + + let callee_ty = module_context.signature(type_index); + + // TODO: this implementation assumes that this function is locally defined. + + ctx.call_indirect( + type_index, + callee_ty.params().iter().map(|t| t.to_microwasm_type()), + callee_ty.returns().iter().map(|t| t.to_microwasm_type()), + )?; + } + } + } + + ctx.epilogue(); + + mem::replace(&mut session.op_offset_map, op_offset_map); + + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +
+#![cfg_attr(test, feature(test))] +#![feature(proc_macro_hygiene)] + +#[cfg(test)] +extern crate test; + +mod backend; +mod disassemble; +mod error; +mod function_body; +mod microwasm; +mod module; +mod translate_sections; + +#[cfg(test)] +mod benches; + +pub use crate::backend::CodeGenSession; +pub use crate::function_body::translate_wasm as translate_function; +pub use crate::module::{ + translate, ExecutableModule, ExecutionError, ModuleContext, Signature, TranslatedModule, +}; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 + 100 + 101 + 102 + 103 + 104 + 105 + 106 + 107 + 108 + 109 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 120 + 121 + 122 + 123 + 124 + 125 + 126 + 127 + 128 + 129 + 130 + 131 + 132 + 133 + 134 + 135 + 136 + 137 + 138 + 139 + 140 + 141 + 142 + 143 + 144 + 145 + 146 + 147 + 148 + 149 + 150 + 151 + 152 + 153 + 154 + 155 + 156 + 157 + 158 + 159 + 160 + 161 + 162 + 163 + 164 + 165 + 166 + 167 + 168 + 169 + 170 + 171 + 172 + 173 + 174 + 175 + 176 + 177 + 178 + 179 + 180 + 181 + 182 + 183 + 184 + 185 + 186 + 187 + 188 + 189 + 190 + 191 + 192 + 193 + 194 + 195 + 196 + 197 + 198 + 199 + 200 + 201 + 202 + 203 + 204 + 205 + 206 + 207 + 208 + 209 + 210 + 211 + 212 + 213 + 214 + 215 + 216 + 217 + 218 + 219 + 220 + 221 + 222 + 223 + 224 + 225 + 226 + 227 + 228 + 229 + 230 + 231 + 232 + 233 + 234 + 235 + 236 + 237 + 238 + 239 + 240 + 241 + 242 + 243 + 244 + 245 + 246 + 247 + 248 + 249 + 250 + 251 + 252 + 253 + 254 + 255 + 256 + 257 + 258 + 259 + 260 + 261 + 262 + 263 + 264 + 265 + 266 + 267 + 268 + 269 + 270 + 271 + 272 + 273 + 274 + 275 + 276 + 277 + 278 + 279 + 280 + 281 + 282 + 283 + 284 + 285 + 286 + 287 + 288 + 289 + 290 + 291 + 292 + 293 + 294 + 295 + 296 + 297 + 298 + 299 + 300 + 301 + 302 + 303 + 304 + 305 + 306 + 307 + 308 + 309 + 310 + 311 + 312 + 313 + 314 + 315 + 316 + 317 + 318 + 319 + 320 + 321 + 322 + 323 + 324 + 325 + 326 + 327 + 328 + 329 + 330 + 331 + 332 + 333 + 334 + 335 + 336 + 337 + 338 + 339 + 340 + 341 + 342 + 343 + 344 + 345 + 346 + 347 + 348 + 349 + 350 + 351 + 352 + 353 + 354 + 355 + 356 + 357 + 358 + 359 + 360 + 361 + 362 + 363 + 364 + 365 + 366 + 367 + 368 + 369 + 370 + 371 + 372 + 373 + 374 + 375 + 376 + 377 + 378 + 379 + 380 + 381 + 382 + 383 + 384 + 385 + 386 + 387 + 388 + 389 + 390 + 391 + 392 + 393 + 394 + 395 + 396 + 397 + 398 + 399 + 400 + 401 + 402 + 403 + 404 + 405 + 406 + 407 + 408 + 409 + 410 + 411 + 412 + 413 + 414 + 415 + 416 + 417 + 418 + 419 + 420 + 421 + 422 + 423 + 424 + 425 + 426 + 427 + 428 + 429 + 430 + 431 + 432 + 433 + 434 + 435 + 436 + 437 + 438 + 439 + 440 + 441 + 442 + 443 + 444 + 445 + 446 + 447 + 448 + 449 + 450 + 451 + 452 + 453 + 454 + 455 + 456 + 457 + 458 + 459 + 460 + 461 + 462 + 463 + 464 + 465 + 466 + 467 + 468 + 469 + 470 + 471 + 472 + 473 + 474 + 475 + 476 + 477 + 478 + 479 + 480 + 481 + 482 + 483 + 484 + 485 + 486 + 487 + 488 + 489 + 490 + 491 + 492 + 493 + 494 + 495 + 496 + 497 + 498 + 499 + 500 + 501 + 502 + 503 + 504 + 505 + 506 + 507 + 508 + 509 + 510 + 511 + 512 + 513 + 514 + 515 + 516 + 517 + 518 + 519 + 520 + 521 + 522 + 523 + 524 + 525 + 526 + 527 + 528 + 529 + 530 + 531 + 532 + 533 + 534 + 535 + 536 + 537 + 538 + 539 + 540 + 541 + 542 + 543 + 544 + 545 + 546 + 547 + 548 + 549 + 550 + 551 + 552 + 553 + 554 + 555 + 556 + 557 + 558 + 559 + 560 + 561 + 562 + 563 + 564 + 565 + 566 + 567 + 568 + 569 + 570 + 571 + 572 + 573 + 574 + 575 + 576 + 577 + 578 + 579 + 580 + 581 + 582 + 583 + 584 + 585 + 586 + 587 + 588 + 589 + 590 + 591 + 592 + 593 + 594 + 595 + 596 + 597 + 598 + 599 + 600 + 601 + 602 + 603 + 604 + 605 + 606 + 607 + 608 + 609 + 610 + 611 + 612 + 613 + 614 + 615 + 616 + 617 + 618 + 619 + 620 + 621 + 622 + 623 + 624 + 625 + 626 + 627 + 628 + 629 + 630 + 631 + 632 + 633 + 634 + 635 + 636 + 637 + 638 + 639 + 640 + 641 + 642 + 643 + 644 + 645 + 646 + 647 + 648 + 649 + 650 + 651 + 652 + 653 + 654 + 655 + 656 + 657 + 658 + 659 + 660 + 661 + 662 + 663 + 664 + 665 + 666 + 667 + 668 + 669 + 670 + 671 + 672 + 673 + 674 + 675 + 676 + 677 + 678 + 679 + 680 + 681 + 682 + 683 + 684 + 685 + 686 + 687 + 688 + 689 + 690 + 691 + 692 + 693 + 694 + 695 + 696 + 697 + 698 + 699 + 700 + 701 + 702 + 703 + 704 + 705 + 706 + 707 + 708 + 709 + 710 + 711 + 712 + 713 + 714 + 715 + 716 + 717 + 718 + 719 + 720 + 721 + 722 + 723 + 724 + 725 + 726 + 727 + 728 + 729 + 730 + 731 + 732 + 733 + 734 + 735 + 736 + 737 + 738 + 739 + 740 + 741 + 742 + 743 + 744 + 745 + 746 + 747 + 748 + 749 + 750 + 751 + 752 + 753 + 754 + 755 + 756 + 757 + 758 + 759 + 760 + 761 + 762 + 763 + 764 + 765 + 766 + 767 + 768 + 769 + 770 + 771 + 772 + 773 + 774 + 775 + 776 + 777 + 778 + 779 + 780 + 781 + 782 + 783 + 784 + 785 + 786 + 787 + 788 + 789 + 790 + 791 + 792 + 793 + 794 + 795 + 796 + 797 + 798 + 799 + 800 + 801 + 802 + 803 + 804 + 805 + 806 + 807 + 808 + 809 + 810 + 811 + 812 + 813 + 814 + 815 + 816 + 817 + 818 + 819 + 820 + 821 + 822 + 823 + 824 + 825 + 826 + 827 + 828 + 829 + 830 + 831 + 832 + 833 + 834 + 835 + 836 + 837 + 838 + 839 + 840 + 841 + 842 + 843 + 844 + 845 + 846 + 847 + 848 + 849 + 850 + 851 + 852 + 853 + 854 + 855 + 856 + 857 + 858 + 859 + 860 + 861 + 862 + 863 + 864 + 865 + 866 + 867 + 868 + 869 + 870 + 871 + 872 + 873 + 874 + 875 + 876 + 877 + 878 + 879 + 880 + 881 + 882 + 883 + 884 + 885 + 886 + 887 + 888 + 889 + 890 + 891 + 892 + 893 + 894 + 895 + 896 + 897 + 898 + 899 + 900 + 901 + 902 + 903 + 904 + 905 + 906 + 907 + 908 + 909 + 910 + 911 + 912 + 913 + 914 + 915 + 916 + 917 + 918 + 919 + 920 + 921 + 922 + 923 + 924 + 925 + 926 + 927 + 928 + 929 + 930 + 931 + 932 + 933 + 934 + 935 + 936 + 937 + 938 + 939 + 940 + 941 + 942 + 943 + 944 + 945 + 946 + 947 + 948 + 949 + 950 + 951 + 952 + 953 + 954 + 955 + 956 + 957 + 958 + 959 + 960 + 961 + 962 + 963 + 964 + 965 + 966 + 967 + 968 + 969 + 970 + 971 + 972 + 973 + 974 + 975 + 976 + 977 + 978 + 979 + 980 + 981 + 982 + 983 + 984 + 985 + 986 + 987 + 988 + 989 + 990 + 991 + 992 + 993 + 994 + 995 + 996 + 997 + 998 + 999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +1093 +1094 +1095 +1096 +1097 +1098 +1099 +1100 +1101 +1102 +1103 +1104 +1105 +1106 +1107 +1108 +1109 +1110 +1111 +1112 +1113 +1114 +1115 +1116 +1117 +1118 +1119 +1120 +1121 +1122 +1123 +1124 +1125 +1126 +1127 +1128 +1129 +1130 +1131 +1132 +1133 +1134 +1135 +1136 +1137 +1138 +1139 +1140 +1141 +1142 +1143 +1144 +1145 +1146 +1147 +1148 +1149 +1150 +1151 +1152 +1153 +1154 +1155 +1156 +1157 +1158 +1159 +1160 +1161 +1162 +1163 +1164 +1165 +1166 +1167 +1168 +1169 +1170 +1171 +1172 +1173 +1174 +1175 +1176 +1177 +1178 +1179 +1180 +1181 +1182 +1183 +1184 +1185 +1186 +1187 +1188 +1189 +1190 +1191 +1192 +1193 +1194 +1195 +1196 +1197 +1198 +1199 +1200 +1201 +1202 +1203 +1204 +1205 +1206 +1207 +1208 +1209 +1210 +1211 +1212 +1213 +1214 +1215 +1216 +1217 +1218 +1219 +1220 +1221 +1222 +1223 +1224 +1225 +1226 +1227 +1228 +1229 +1230 +1231 +1232 +1233 +1234 +1235 +1236 +1237 +1238 +1239 +1240 +1241 +1242 +1243 +1244 +1245 +1246 +1247 +1248 +1249 +1250 +1251 +1252 +1253 +1254 +1255 +1256 +1257 +1258 +1259 +1260 +1261 +1262 +1263 +1264 +1265 +1266 +1267 +1268 +1269 +1270 +1271 +1272 +1273 +1274 +1275 +1276 +1277 +1278 +1279 +1280 +1281 +1282 +1283 +1284 +1285 +1286 +1287 +1288 +1289 +1290 +1291 +1292 +1293 +1294 +1295 +1296 +1297 +1298 +1299 +1300 +1301 +1302 +1303 +1304 +1305 +1306 +1307 +1308 +1309 +1310 +1311 +1312 +1313 +1314 +1315 +1316 +1317 +1318 +1319 +1320 +1321 +1322 +1323 +1324 +1325 +1326 +1327 +1328 +1329 +1330 +1331 +1332 +1333 +1334 +1335 +1336 +1337 +1338 +1339 +1340 +1341 +1342 +1343 +1344 +1345 +1346 +1347 +1348 +1349 +1350 +1351 +1352 +1353 +1354 +1355 +1356 +1357 +1358 +1359 +1360 +1361 +1362 +1363 +1364 +1365 +1366 +1367 +1368 +1369 +1370 +1371 +1372 +1373 +1374 +1375 +1376 +1377 +1378 +1379 +1380 +1381 +1382 +1383 +1384 +1385 +1386 +1387 +1388 +1389 +1390 +1391 +1392 +1393 +1394 +1395 +1396 +1397 +1398 +1399 +1400 +1401 +1402 +1403 +1404 +1405 +1406 +1407 +1408 +1409 +1410 +1411 +1412 +1413 +1414 +1415 +1416 +1417 +1418 +1419 +1420 +1421 +1422 +1423 +1424 +1425 +1426 +1427 +1428 +1429 +1430 +1431 +1432 +1433 +1434 +1435 +1436 +1437 +1438 +1439 +1440 +1441 +1442 +1443 +1444 +1445 +1446 +1447 +1448 +1449 +1450 +1451 +1452 +1453 +1454 +1455 +1456 +1457 +1458 +1459 +1460 +1461 +1462 +1463 +1464 +1465 +1466 +1467 +1468 +1469 +1470 +1471 +1472 +1473 +1474 +1475 +1476 +1477 +1478 +1479 +1480 +1481 +1482 +1483 +1484 +1485 +1486 +1487 +1488 +1489 +1490 +1491 +1492 +1493 +1494 +1495 +1496 +1497 +1498 +1499 +1500 +1501 +1502 +1503 +1504 +1505 +1506 +1507 +1508 +1509 +1510 +1511 +1512 +1513 +1514 +1515 +1516 +1517 +1518 +1519 +1520 +1521 +1522 +1523 +1524 +1525 +1526 +1527 +1528 +1529 +1530 +1531 +1532 +1533 +1534 +1535 +1536 +1537 +1538 +1539 +1540 +1541 +1542 +1543 +1544 +1545 +1546 +1547 +1548 +1549 +1550 +1551 +1552 +1553 +1554 +1555 +1556 +1557 +1558 +1559 +1560 +1561 +1562 +1563 +1564 +1565 +1566 +1567 +1568 +1569 +1570 +1571 +1572 +1573 +1574 +1575 +1576 +1577 +1578 +1579 +1580 +1581 +1582 +1583 +1584 +1585 +1586 +1587 +1588 +1589 +1590 +1591 +1592 +1593 +1594 +1595 +1596 +1597 +1598 +1599 +1600 +1601 +1602 +1603 +1604 +1605 +1606 +1607 +1608 +1609 +1610 +1611 +1612 +1613 +1614 +1615 +1616 +1617 +1618 +1619 +1620 +1621 +1622 +1623 +1624 +1625 +1626 +1627 +1628 +1629 +1630 +1631 +1632 +1633 +1634 +1635 +1636 +1637 +1638 +1639 +1640 +1641 +1642 +1643 +1644 +1645 +1646 +1647 +1648 +1649 +1650 +1651 +1652 +1653 +1654 +1655 +1656 +1657 +1658 +1659 +1660 +1661 +1662 +1663 +1664 +1665 +1666 +1667 +1668 +1669 +1670 +1671 +1672 +1673 +1674 +1675 +1676 +1677 +1678 +1679 +1680 +1681 +1682 +1683 +1684 +1685 +1686 +1687 +1688 +1689 +1690 +1691 +1692 +1693 +1694 +1695 +1696 +1697 +1698 +1699 +1700 +1701 +1702 +1703 +1704 +1705 +1706 +1707 +1708 +1709 +1710 +1711 +1712 +1713 +1714 +1715 +1716 +1717 +1718 +1719 +1720 +1721 +1722 +1723 +1724 +1725 +1726 +1727 +1728 +1729 +1730 +1731 +1732 +1733 +1734 +1735 +1736 +1737 +1738 +1739 +1740 +1741 +1742 +1743 +1744 +1745 +1746 +1747 +1748 +1749 +1750 +1751 +1752 +1753 +1754 +1755 +1756 +1757 +1758 +1759 +1760 +1761 +1762 +1763 +1764 +1765 +1766 +1767 +1768 +1769 +1770 +1771 +1772 +1773 +1774 +1775 +1776 +1777 +1778 +1779 +1780 +1781 +1782 +1783 +1784 +1785 +1786 +1787 +1788 +1789 +1790 +1791 +1792 +1793 +1794 +1795 +1796 +1797 +1798 +1799 +1800 +1801 +1802 +1803 +1804 +1805 +1806 +1807 +1808 +1809 +1810 +1811 +1812 +1813 +1814 +1815 +1816 +1817 +1818 +1819 +1820 +1821 +1822 +1823 +1824 +1825 +1826 +1827 +1828 +1829 +1830 +1831 +1832 +1833 +1834 +1835 +1836 +1837 +1838 +1839 +1840 +1841 +1842 +1843 +1844 +1845 +1846 +1847 +1848 +1849 +1850 +1851 +1852 +1853 +1854 +1855 +1856 +1857 +1858 +1859 +1860 +1861 +1862 +1863 +1864 +1865 +1866 +1867 +1868 +1869 +1870 +1871 +1872 +1873 +1874 +1875 +1876 +1877 +1878 +1879 +1880 +1881 +1882 +1883 +1884 +1885 +1886 +1887 +1888 +1889 +1890 +1891 +1892 +1893 +1894 +1895 +1896 +1897 +1898 +1899 +1900 +1901 +1902 +1903 +1904 +1905 +1906 +1907 +1908 +1909 +1910 +1911 +1912 +1913 +1914 +1915 +1916 +1917 +1918 +1919 +1920 +1921 +1922 +1923 +1924 +1925 +1926 +1927 +1928 +1929 +1930 +1931 +1932 +1933 +1934 +1935 +1936 +1937 +1938 +1939 +1940 +1941 +1942 +1943 +1944 +1945 +1946 +1947 +1948 +1949 +1950 +1951 +1952 +1953 +1954 +1955 +1956 +1957 +1958 +1959 +1960 +1961 +1962 +1963 +1964 +1965 +1966 +1967 +1968 +1969 +1970 +1971 +1972 +1973 +1974 +1975 +1976 +1977 +1978 +1979 +1980 +1981 +1982 +1983 +1984 +1985 +1986 +1987 +1988 +1989 +1990 +1991 +1992 +1993 +1994 +1995 +1996 +1997 +1998 +1999 +2000 +2001 +2002 +2003 +2004 +2005 +2006 +2007 +2008 +2009 +2010 +2011 +2012 +2013 +2014 +2015 +2016 +2017 +2018 +2019 +2020 +2021 +2022 +2023 +2024 +2025 +2026 +2027 +2028 +2029 +2030 +2031 +2032 +2033 +2034 +2035 +2036 +2037 +2038 +2039 +2040 +2041 +2042 +2043 +2044 +2045 +2046 +2047 +2048 +2049 +2050 +2051 +2052 +2053 +2054 +2055 +2056 +2057 +2058 +2059 +2060 +2061 +2062 +2063 +2064 +2065 +2066 +2067 +2068 +2069 +2070 +2071 +2072 +2073 +2074 +2075 +2076 +2077 +2078 +2079 +2080 +2081 +2082 +2083 +2084 +2085 +2086 +2087 +2088 +2089 +2090 +2091 +2092 +2093 +2094 +2095 +2096 +2097 +2098 +2099 +2100 +2101 +2102 +2103 +2104 +2105 +2106 +2107 +2108 +2109 +2110 +2111 +2112 +2113 +2114 +2115 +2116 +2117 +2118 +2119 +2120 +2121 +2122 +2123 +2124 +2125 +2126 +2127 +2128 +2129 +2130 +2131 +2132 +2133 +2134 +2135 +2136 +2137 +2138 +2139 +2140 +2141 +2142 +2143 +2144 +2145 +2146 +2147 +2148 +2149 +2150 +2151 +2152 +2153 +2154 +2155 +2156 +2157 +2158 +2159 +2160 +2161 +2162 +2163 +2164 +2165 +2166 +2167 +2168 +2169 +2170 +2171 +2172 +2173 +2174 +2175 +2176 +2177 +2178 +2179 +2180 +2181 +2182 +2183 +2184 +2185 +2186 +2187 +2188 +2189 +2190 +2191 +2192 +2193 +2194 +2195 +2196 +2197 +2198 +2199 +2200 +2201 +2202 +2203 +2204 +2205 +2206 +2207 +2208 +2209 +2210 +2211 +2212 +2213 +2214 +2215 +2216 +2217 +2218 +2219 +2220 +2221 +2222 +2223 +2224 +2225 +2226 +2227 +2228 +2229 +2230 +2231 +2232 +2233 +2234 +2235 +2236 +2237 +2238 +2239 +2240 +2241 +2242 +2243 +2244 +2245 +2246 +2247 +2248 +2249 +2250 +2251 +2252 +2253 +2254 +2255 +2256 +2257 +2258 +
+use crate::error::Error; +use crate::module::{ModuleContext, SigType, Signature}; +use smallvec::{smallvec, SmallVec}; +use std::{ + convert::TryInto, + fmt, + iter::{self, FromIterator}, + ops::RangeInclusive, +}; +use wasmparser::{ + FunctionBody, Ieee32 as WasmIeee32, Ieee64 as WasmIeee64, + MemoryImmediate as WasmMemoryImmediate, Operator as WasmOperator, OperatorsReader, +}; + +pub fn dis<L>( + mut out: impl std::io::Write, + function_name: impl fmt::Display, + microwasm: impl IntoIterator<Item = Operator<L>>, +) -> std::io::Result<()> +where + BrTarget<L>: fmt::Display, + L: Clone, +{ + writeln!(out, ".fn_{}:", function_name)?; + + let p = " "; + for op in microwasm { + if op.is_label() || op.is_block() { + writeln!(out, "{}", op)?; + } else { + writeln!(out, "{}{}", p, op)?; + } + } + + Ok(()) +} + +/// A constant value embedded in the instructions +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Value { + I32(i32), + I64(i64), + F32(Ieee32), + F64(Ieee64), +} + +impl fmt::Display for Value { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Value::I32(v) => write!(f, "{}i32", v), + Value::I64(v) => write!(f, "{}i64", v), + Value::F32(v) => write!(f, "{}f32", f32::from_bits(v.to_bits())), + Value::F64(v) => write!(f, "{}f64", f64::from_bits(v.to_bits())), + } + } +} + +impl Value { + pub fn as_int(self) -> Option<i64> { + self.as_i64().or_else(|| self.as_i32().map(|i| i as _)) + } + + pub fn as_bytes(self) -> i64 { + match self { + Value::I32(val) => val as _, + Value::I64(val) => val, + Value::F32(val) => val.0 as _, + Value::F64(val) => val.0 as _, + } + } + + pub fn as_i32(self) -> Option<i32> { + match self { + Value::I32(val) => Some(val), + _ => None, + } + } + + pub fn as_i64(self) -> Option<i64> { + match self { + Value::I64(val) => Some(val), + _ => None, + } + } + + pub fn as_f32(self) -> Option<Ieee32> { + match self { + Value::F32(val) => Some(val), + _ => None, + } + } + + pub fn as_f64(self) -> Option<Ieee64> { + match self { + Value::F64(val) => Some(val), + _ => None, + } + } + + pub fn type_(&self) -> SignlessType { + match self { + Value::I32(_) => Type::Int(Size::_32), + Value::I64(_) => Type::Int(Size::_64), + Value::F32(Ieee32(_)) => Type::Float(Size::_32), + Value::F64(Ieee64(_)) => Type::Float(Size::_64), + } + } + + fn default_for_type(ty: SignlessType) -> Self { + match ty { + Type::Int(Size::_32) => Value::I32(0), + Type::Int(Size::_64) => Value::I64(0), + Type::Float(Size::_32) => Value::F32(Ieee32(0)), + Type::Float(Size::_64) => Value::F64(Ieee64(0)), + } + } +} + +impl From<i32> for Value { + fn from(other: i32) -> Self { + Value::I32(other) + } +} +impl From<i64> for Value { + fn from(other: i64) -> Self { + Value::I64(other) + } +} +impl From<u32> for Value { + fn from(other: u32) -> Self { + Value::I32(other as _) + } +} +impl From<u64> for Value { + fn from(other: u64) -> Self { + Value::I64(other as _) + } +} +impl From<Ieee32> for Value { + fn from(other: Ieee32) -> Self { + Value::F32(other) + } +} +impl From<Ieee64> for Value { + fn from(other: Ieee64) -> Self { + Value::F64(other) + } +} + +/// Whether to interpret an integer as signed or unsigned +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Signedness { + Signed, + Unsigned, +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Size { + _32, + _64, +} + +type Int = Size; +type Float = Size; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub struct SignfulInt(pub Signedness, pub Size); + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Type<I> { + Int(I), + Float(Size), +} + +pub trait IntoType<T> { + fn into_type() -> T; +} + +impl IntoType<SignlessType> for i32 { + fn into_type() -> SignlessType { + I32 + } +} + +impl IntoType<SignlessType> for i64 { + fn into_type() -> SignlessType { + I64 + } +} + +impl IntoType<SignlessType> for u32 { + fn into_type() -> SignlessType { + I32 + } +} + +impl IntoType<SignlessType> for u64 { + fn into_type() -> SignlessType { + I64 + } +} + +impl IntoType<SignlessType> for f32 { + fn into_type() -> SignlessType { + F32 + } +} + +impl IntoType<SignlessType> for f64 { + fn into_type() -> SignlessType { + F64 + } +} + +impl<I> Type<I> { + pub fn for_<T: IntoType<Self>>() -> Self { + T::into_type() + } +} + +impl fmt::Display for SignfulType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Type::Int(i) => write!(f, "{}", i), + Type::Float(Size::_32) => write!(f, "f32"), + Type::Float(Size::_64) => write!(f, "f64"), + } + } +} + +impl fmt::Display for SignlessType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Type::Int(Size::_32) => write!(f, "i32"), + Type::Int(Size::_64) => write!(f, "i64"), + Type::Float(Size::_32) => write!(f, "f32"), + Type::Float(Size::_64) => write!(f, "f64"), + } + } +} + +impl fmt::Display for SignfulInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + SignfulInt(Signedness::Signed, Size::_32) => write!(f, "i32"), + SignfulInt(Signedness::Unsigned, Size::_32) => write!(f, "u32"), + SignfulInt(Signedness::Signed, Size::_64) => write!(f, "i64"), + SignfulInt(Signedness::Unsigned, Size::_64) => write!(f, "u64"), + } + } +} + +pub type SignlessType = Type<Size>; +pub type SignfulType = Type<SignfulInt>; + +pub const I32: SignlessType = Type::Int(Size::_32); +pub const I64: SignlessType = Type::Int(Size::_64); +pub const F32: SignlessType = Type::Float(Size::_32); +pub const F64: SignlessType = Type::Float(Size::_64); + +pub mod sint { + use super::{Signedness, SignfulInt, Size}; + + pub const I32: SignfulInt = SignfulInt(Signedness::Signed, Size::_32); + pub const I64: SignfulInt = SignfulInt(Signedness::Signed, Size::_64); + pub const U32: SignfulInt = SignfulInt(Signedness::Unsigned, Size::_32); + pub const U64: SignfulInt = SignfulInt(Signedness::Unsigned, Size::_64); +} + +pub const SI32: SignfulType = Type::Int(sint::I32); +pub const SI64: SignfulType = Type::Int(sint::I64); +pub const SU32: SignfulType = Type::Int(sint::U32); +pub const SU64: SignfulType = Type::Int(sint::U64); +pub const SF32: SignfulType = Type::Float(Size::_32); +pub const SF64: SignfulType = Type::Float(Size::_64); + +impl SignlessType { + pub fn from_wasm(other: wasmparser::Type) -> Result<Self, Error> { + use wasmparser::Type; + + match other { + Type::I32 => Ok(I32), + Type::I64 => Ok(I64), + Type::F32 => Ok(F32), + Type::F64 => Ok(F64), + Type::EmptyBlockType => Err(Error::Microwasm( + "SignlessType with EmptyBlockType".to_string(), + )), + _ => Err(Error::Microwasm("SignlessType unimplemented".to_string())), + } + } +} + +fn create_returns_from_wasm_type( + ty: wasmparser::TypeOrFuncType, +) -> Result<Vec<SignlessType>, Error> { + match ty { + wasmparser::TypeOrFuncType::Type(ty) => Ok(Vec::from_iter(Type::from_wasm(ty))), + wasmparser::TypeOrFuncType::FuncType(_) => { + Err(Error::Microwasm("Unsupported func type".to_string())) + } + } +} + +#[derive(Debug, Clone)] +pub struct BrTable<L> { + pub targets: Vec<BrTargetDrop<L>>, + pub default: BrTargetDrop<L>, +} + +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub enum NameTag { + Header, + Else, + End, +} + +pub type WasmLabel = (u32, NameTag); + +pub type OperatorFromWasm = Operator<WasmLabel>; + +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)] +pub enum BrTarget<L> { + Return, + Label(L), +} + +impl<L> BrTarget<L> { + pub fn label(&self) -> Option<&L> { + match self { + BrTarget::Return => None, + BrTarget::Label(l) => Some(l), + } + } +} + +impl<L> From<L> for BrTarget<L> { + fn from(other: L) -> Self { + BrTarget::Label(other) + } +} + +impl fmt::Display for BrTarget<WasmLabel> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + BrTarget::Return => write!(f, ".return"), + BrTarget::Label((i, NameTag::Header)) => write!(f, ".L{}", i), + BrTarget::Label((i, NameTag::Else)) => write!(f, ".L{}_else", i), + BrTarget::Label((i, NameTag::End)) => write!(f, ".L{}_end", i), + } + } +} + +impl fmt::Display for BrTarget<&str> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + BrTarget::Return => write!(f, ".return"), + BrTarget::Label(l) => write!(f, ".L{}", l), + } + } +} + +#[derive(Debug, Clone, Hash, PartialEq, Eq)] +pub struct BrTargetDrop<L> { + pub target: BrTarget<L>, + pub to_drop: Option<RangeInclusive<u32>>, +} + +impl<L> From<BrTarget<L>> for BrTargetDrop<L> { + fn from(other: BrTarget<L>) -> Self { + BrTargetDrop { + target: other, + to_drop: None, + } + } +} + +impl<L> fmt::Display for BrTargetDrop<L> +where + BrTarget<L>: fmt::Display, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if let Some(drop) = &self.to_drop { + write!( + f, + "({}, drop {}..={})", + self.target, + drop.start(), + drop.end() + ) + } else { + write!(f, "{}", self.target) + } + } +} + +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct Ieee32(u32); +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +pub struct Ieee64(u64); + +impl Ieee32 { + pub fn to_bits(self) -> u32 { + self.0 + } + + pub fn from_bits(other: u32) -> Self { + Ieee32(other) + } +} + +impl From<WasmIeee32> for Ieee32 { + fn from(other: WasmIeee32) -> Self { + Self::from_bits(other.bits()) + } +} + +impl Ieee64 { + pub fn to_bits(self) -> u64 { + self.0 + } + + pub fn from_bits(other: u64) -> Self { + Ieee64(other) + } +} + +impl From<WasmIeee64> for Ieee64 { + fn from(other: WasmIeee64) -> Self { + Self::from_bits(other.bits()) + } +} + +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct MemoryImmediate { + pub flags: u32, + pub offset: u32, +} + +impl From<WasmMemoryImmediate> for MemoryImmediate { + fn from(other: WasmMemoryImmediate) -> Self { + MemoryImmediate { + flags: other.flags, + offset: other.offset, + } + } +} + +// TODO: Explicit VmCtx? +#[derive(Debug, Clone)] +pub enum Operator<Label> { + /// Explicit trap instruction + Unreachable, + /// Define metadata for a block - its label, its signature, whether it has backwards callers etc. It + /// is an error to branch to a block that has yet to be defined. + Block { + label: Label, + // TODO: Do we need this? + params: Vec<SignlessType>, + // TODO: Ideally we'd have `num_backwards_callers` but we can't know that for WebAssembly + has_backwards_callers: bool, + num_callers: Option<u32>, + }, + /// Start a new block. It is an error if the previous block has not been closed by emitting a `Br` or + /// `BrTable`. + Label(Label), + /// Unconditionally break to a new block. This the parameters off the stack and passes them into + /// the new block. Any remaining elements on the stack are discarded. + Br { + /// Returning from the function is just calling the "return" block + target: BrTarget<Label>, + }, + /// Pop a value off the top of the stack, jump to the `else_` label if this value is `true` + /// and the `then` label otherwise. The `then` and `else_` blocks must have the same parameters. + BrIf { + /// Label to jump to if the value at the top of the stack is true + then: BrTargetDrop<Label>, + /// Label to jump to if the value at the top of the stack is false + else_: BrTargetDrop<Label>, + }, + /// Pop a value off the top of the stack, jump to `table[value.min(table.len() - 1)]`. All elements + /// in the table must have the same parameters. + BrTable( + /// The table of labels to jump to - the index should be clamped to the length of the table + BrTable<Label>, + ), + /// Call a function + Call { + function_index: u32, + }, + /// Pop an `i32` off the top of the stack, index into the table at `table_index` and call that function + CallIndirect { + type_index: u32, + table_index: u32, + }, + /// Pop an element off of the stack and discard it. + Drop(RangeInclusive<u32>), + /// Pop an `i32` off of the stack and 2 elements off of the stack, call them `A` and `B` where `A` is the + /// first element popped and `B` is the second. If the `i32` is 0 then discard `B` and push `A` back onto + /// the stack, otherwise discard `A` and push `B` back onto the stack. + Select, + /// Duplicate the element at depth `depth` to the top of the stack. This can be used to implement + /// `LocalGet`. + Pick(u32), + /// Swap the top element of the stack with the element at depth `depth`. This can be used to implement + /// `LocalSet`. + // TODO: Is it better to have `Swap`, to have `Pull` (which moves the `nth` element instead of swapping) + // or to have both? + Swap(u32), + GlobalGet(u32), + GlobalSet(u32), + Load { + ty: SignlessType, + memarg: MemoryImmediate, + }, + Load8 { + ty: SignfulInt, + memarg: MemoryImmediate, + }, + Load16 { + ty: SignfulInt, + memarg: MemoryImmediate, + }, + // Only available for {I,U}64 + // TODO: Roll this into `Load` somehow? + Load32 { + sign: Signedness, + memarg: MemoryImmediate, + }, + Store { + ty: SignlessType, + memarg: MemoryImmediate, + }, + Store8 { + /// `ty` on integers + ty: Int, + memarg: MemoryImmediate, + }, + Store16 { + /// `ty` on integers + ty: Int, + memarg: MemoryImmediate, + }, + // Only available for I64 + // TODO: Roll this into `Store` somehow? + Store32 { + memarg: MemoryImmediate, + }, + MemorySize { + reserved: u32, + }, + MemoryGrow { + reserved: u32, + }, + Const(Value), + Eq(SignlessType), + Ne(SignlessType), + /// `eqz` on integers + Eqz(Int), + Lt(SignfulType), + Gt(SignfulType), + Le(SignfulType), + Ge(SignfulType), + Add(SignlessType), + Sub(SignlessType), + Mul(SignlessType), + /// `clz` on integers + Clz(Int), + /// `ctz` on integers + Ctz(Int), + /// `popcnt` on integers + Popcnt(Int), + Div(SignfulType), + Rem(SignfulInt), + And(Int), + Or(Int), + Xor(Int), + Shl(Int), + Shr(SignfulInt), + Rotl(Int), + Rotr(Int), + Abs(Float), + Neg(Float), + Ceil(Float), + Floor(Float), + Trunc(Float), + Nearest(Float), + Sqrt(Float), + Min(Float), + Max(Float), + Copysign(Float), + I32WrapFromI64, + ITruncFromF { + input_ty: Float, + output_ty: SignfulInt, + }, + FConvertFromI { + input_ty: SignfulInt, + output_ty: Float, + }, + F32DemoteFromF64, + F64PromoteFromF32, + I32ReinterpretFromF32, + I64ReinterpretFromF64, + F32ReinterpretFromI32, + F64ReinterpretFromI64, + // Only available for input I32 and output I64 + Extend { + sign: Signedness, + }, +} + +impl<L> Operator<L> { + pub fn is_label(&self) -> bool { + match self { + Operator::Label(..) => true, + _ => false, + } + } + + pub fn is_block(&self) -> bool { + match self { + Operator::Block { .. } => true, + _ => false, + } + } + + pub fn end(params: Vec<SignlessType>, label: L) -> Self { + Operator::Block { + params, + label, + has_backwards_callers: false, + // TODO + num_callers: None, + } + } + + pub fn block(params: Vec<SignlessType>, label: L) -> Self { + Operator::Block { + params, + label, + has_backwards_callers: false, + num_callers: Some(1), + } + } + + pub fn loop_(params: Vec<SignlessType>, label: L) -> Self { + Operator::Block { + params, + label, + has_backwards_callers: true, + num_callers: None, + } + } +} + +impl<L> fmt::Display for Operator<L> +where + BrTarget<L>: fmt::Display, + L: Clone, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Operator::Unreachable => write!(f, "unreachable"), + Operator::Label(label) => write!(f, "{}:", BrTarget::Label(label.clone())), + Operator::Block { + label, + params, + has_backwards_callers, + num_callers, + } => { + write!(f, "def {} :: [", BrTarget::Label(label.clone()))?; + let mut iter = params.iter(); + if let Some(p) = iter.next() { + write!(f, "{}", p)?; + for p in iter { + write!(f, ", {}", p)?; + } + } + write!(f, "]")?; + + if *has_backwards_callers { + write!(f, " has_backwards_callers")?; + } + + if let Some(n) = num_callers { + write!(f, " num_callers={}", n)?; + } + + Ok(()) + } + Operator::Br { target } => write!(f, "br {}", target), + Operator::BrIf { then, else_ } => write!(f, "br_if {}, {}", then, else_), + Operator::BrTable(BrTable { targets, default }) => { + write!(f, "br_table [")?; + let mut iter = targets.iter(); + if let Some(p) = iter.next() { + write!(f, "{}", p)?; + for p in iter { + write!(f, ", {}", p)?; + } + } + + write!(f, "], {}", default) + } + Operator::Call { function_index } => write!(f, "call {}", function_index), + Operator::CallIndirect { .. } => write!(f, "call_indirect"), + Operator::Drop(range) => { + write!(f, "drop")?; + + match range.clone().into_inner() { + (0, 0) => {} + (start, end) if start == end => { + write!(f, " {}", start)?; + } + (start, end) => { + write!(f, " {}..={}", start, end)?; + } + } + + Ok(()) + } + Operator::Select => write!(f, "select"), + Operator::Pick(depth) => write!(f, "pick {}", depth), + Operator::Swap(depth) => write!(f, "swap {}", depth), + Operator::Load { ty, memarg } => { + write!(f, "{}.load {}, {}", ty, memarg.flags, memarg.offset) + } + Operator::Load8 { ty, memarg } => { + write!(f, "{}.load8 {}, {}", ty, memarg.flags, memarg.offset) + } + Operator::Load16 { ty, memarg } => { + write!(f, "{}.load16 {}, {}", ty, memarg.flags, memarg.offset) + } + Operator::Load32 { sign, memarg } => write!( + f, + "{}.load32 {}, {}", + SignfulInt(*sign, Size::_64), + memarg.flags, + memarg.offset + ), + Operator::Store { ty, memarg } => { + write!(f, "{}.store {}, {}", ty, memarg.flags, memarg.offset) + } + Operator::Store8 { ty, memarg } => write!( + f, + "{}.store8 {}, {}", + SignfulInt(Signedness::Unsigned, *ty), + memarg.flags, + memarg.offset + ), + Operator::Store16 { ty, memarg } => write!( + f, + "{}.store16 {}, {}", + SignfulInt(Signedness::Unsigned, *ty), + memarg.flags, + memarg.offset + ), + Operator::Store32 { memarg } => { + write!(f, "u64.store32 {}, {}", memarg.flags, memarg.offset) + } + Operator::MemorySize { .. } => write!(f, "memory.size"), + Operator::MemoryGrow { .. } => write!(f, "memory.grow"), + Operator::Const(val) => write!(f, "const {}", val), + Operator::Eq(ty) => write!(f, "{}.eq", ty), + Operator::Ne(ty) => write!(f, "{}.ne", ty), + Operator::Eqz(ty) => write!(f, "{}.eqz", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Lt(ty) => write!(f, "{}.lt", ty), + Operator::Gt(ty) => write!(f, "{}.gt", ty), + Operator::Le(ty) => write!(f, "{}.le", ty), + Operator::Ge(ty) => write!(f, "{}.ge", ty), + Operator::Add(ty) => write!(f, "{}.add", ty), + Operator::Sub(ty) => write!(f, "{}.sub", ty), + Operator::Mul(ty) => write!(f, "{}.mul", ty), + Operator::Clz(ty) => write!(f, "{}.clz", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Ctz(ty) => write!(f, "{}.ctz", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Popcnt(ty) => write!(f, "{}.popcnt", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Div(ty) => write!(f, "{}.div", ty), + Operator::Rem(ty) => write!(f, "{}.rem", ty), + Operator::And(ty) => write!(f, "{}.and", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Or(ty) => write!(f, "{}.or", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Xor(ty) => write!(f, "{}.xor", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Shl(ty) => write!(f, "{}.shl", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Shr(ty) => write!(f, "{}.shr", ty), + Operator::Rotl(ty) => write!(f, "{}.rotl", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Rotr(ty) => write!(f, "{}.rotr", SignfulInt(Signedness::Unsigned, *ty)), + Operator::Abs(ty) => write!(f, "{}.abs", Type::<Int>::Float(*ty)), + Operator::Neg(ty) => write!(f, "{}.neg", Type::<Int>::Float(*ty)), + Operator::Ceil(ty) => write!(f, "{}.ceil", Type::<Int>::Float(*ty)), + Operator::Floor(ty) => write!(f, "{}.floor", Type::<Int>::Float(*ty)), + Operator::Trunc(ty) => write!(f, "{}.trunc", Type::<Int>::Float(*ty)), + Operator::Nearest(ty) => write!(f, "{}.nearest", Type::<Int>::Float(*ty)), + Operator::Sqrt(ty) => write!(f, "{}.sqrt", Type::<Int>::Float(*ty)), + Operator::Min(ty) => write!(f, "{}.min", Type::<Int>::Float(*ty)), + Operator::Max(ty) => write!(f, "{}.max", Type::<Int>::Float(*ty)), + Operator::Copysign(ty) => write!(f, "{}.copysign", Type::<Int>::Float(*ty)), + Operator::I32WrapFromI64 => write!(f, "i32.wrap_from.i64"), + Operator::F32DemoteFromF64 => write!(f, "f32.demote_from.f64"), + Operator::F64PromoteFromF32 => write!(f, "f64.promote_from.f32"), + Operator::I32ReinterpretFromF32 => write!(f, "i32.reinterpret_from.f32"), + Operator::I64ReinterpretFromF64 => write!(f, "i64.reinterpret_from.f64"), + Operator::F32ReinterpretFromI32 => write!(f, "f32.reinterpret_from.i32"), + Operator::F64ReinterpretFromI64 => write!(f, "f64.reinterpret_from.i64"), + Operator::FConvertFromI { + input_ty, + output_ty, + } => write!( + f, + "{}.convert_from.{}", + Type::Float::<Int>(*output_ty), + input_ty, + ), + Operator::GlobalGet(index) => write!(f, "global.get {}", index), + Operator::GlobalSet(index) => write!(f, "global.set {}", index), + Operator::ITruncFromF { + input_ty, + output_ty, + } => write!( + f, + "{}.truncate_from.{}", + output_ty, + Type::<Int>::Float(*input_ty) + ), + Operator::Extend { sign } => write!( + f, + "{}.extend_from.{}", + SignfulInt(*sign, Size::_64), + SignfulInt(*sign, Size::_32) + ), + } + } +} + +// TODO: If we return a `Vec<<T as MicrowasmReceiver>::Item>` will that convert to (essentially) a no-op +// in the case that `Item` is a ZST? That is important for ensuring that we don't do unnecessary +// work when we're directly generating asm. +/// WIP: Trait to abstract over either producing a stream of Microwasm or directly producing assembly +/// from the Wasm. This should give a significant speedup since we don't need to allocate any vectors +/// or pay the cost of branches - we can just use iterators and direct function calls. +pub trait MicrowasmReceiver<Label> { + type Item; + + fn unreachable(&mut self) -> Self::Item; + fn block( + &mut self, + label: Label, + params: impl Iterator<Item = SignlessType>, + has_backwards_callers: bool, + num_callers: Option<u32>, + ) -> Self::Item; + fn label(&mut self, _: Label) -> Self::Item; + fn br(&mut self, target: BrTarget<Label>) -> Self::Item; + fn br_if(&mut self, then: BrTargetDrop<Label>, else_: BrTargetDrop<Label>) -> Self::Item; + fn br_table(&mut self, _: BrTable<Label>) -> Self::Item; + fn call(&mut self, function_index: u32) -> Self::Item; + fn call_indirect(&mut self, type_index: u32, table_index: u32) -> Self::Item; + fn drop(&mut self, _: RangeInclusive<u32>) -> Self::Item; + fn select(&mut self) -> Self::Item; + fn pick(&mut self, _: u32) -> Self::Item; + fn swap(&mut self, _: u32) -> Self::Item; + fn get_global(&mut self, index: u32) -> Self::Item; + fn set_global(&mut self, index: u32) -> Self::Item; + fn load(&mut self, ty: SignlessType, memarg: MemoryImmediate) -> Self::Item; + fn load8(&mut self, ty: SignfulInt, memarg: MemoryImmediate) -> Self::Item; + fn load16(&mut self, ty: SignfulInt, memarg: MemoryImmediate) -> Self::Item; + fn load32(&mut self, sign: Signedness, memarg: MemoryImmediate) -> Self::Item; + fn store(&mut self, ty: SignlessType, memarg: MemoryImmediate) -> Self::Item; + fn store8(&mut self, ty: Int, memarg: MemoryImmediate) -> Self::Item; + fn store16(&mut self, ty: Int, memarg: MemoryImmediate) -> Self::Item; + fn store32(&mut self, memarg: MemoryImmediate) -> Self::Item; + fn memory_size(&mut self, reserved: u32) -> Self::Item; + fn memory_grow(&mut self, reserved: u32) -> Self::Item; + fn const_(&mut self, _: Value) -> Self::Item; + fn ref_null(&mut self) -> Self::Item; + fn ref_is_null(&mut self) -> Self::Item; + fn eq(&mut self, _: SignlessType) -> Self::Item; + fn ne(&mut self, _: SignlessType) -> Self::Item; + fn eqz(&mut self, _: Int) -> Self::Item; + fn lt(&mut self, _: SignfulType) -> Self::Item; + fn gt(&mut self, _: SignfulType) -> Self::Item; + fn le(&mut self, _: SignfulType) -> Self::Item; + fn ge(&mut self, _: SignfulType) -> Self::Item; + fn add(&mut self, _: SignlessType) -> Self::Item; + fn sub(&mut self, _: SignlessType) -> Self::Item; + fn mul(&mut self, _: SignlessType) -> Self::Item; + fn clz(&mut self, _: Int) -> Self::Item; + fn ctz(&mut self, _: Int) -> Self::Item; + fn popcnt(&mut self, _: Int) -> Self::Item; + fn div(&mut self, _: SignfulType) -> Self::Item; + fn rem(&mut self, _: SignfulInt) -> Self::Item; + fn and(&mut self, _: Int) -> Self::Item; + fn or(&mut self, _: Int) -> Self::Item; + fn xor(&mut self, _: Int) -> Self::Item; + fn shl(&mut self, _: Int) -> Self::Item; + fn shr(&mut self, _: SignfulInt) -> Self::Item; + fn rotl(&mut self, _: Int) -> Self::Item; + fn rotr(&mut self, _: Int) -> Self::Item; + fn abs(&mut self, _: Float) -> Self::Item; + fn neg(&mut self, _: Float) -> Self::Item; + fn ceil(&mut self, _: Float) -> Self::Item; + fn floor(&mut self, _: Float) -> Self::Item; + fn trunc(&mut self, _: Float) -> Self::Item; + fn nearest(&mut self, _: Float) -> Self::Item; + fn sqrt(&mut self, _: Float) -> Self::Item; + fn min(&mut self, _: Float) -> Self::Item; + fn max(&mut self, _: Float) -> Self::Item; + fn copysign(&mut self, _: Float) -> Self::Item; + fn i32_wrap_from_i64(&mut self) -> Self::Item; + fn i_trunc_from_f(&mut self, input_ty: Float, output_ty: SignfulInt) -> Self::Item; + fn f_convert_from_i(&mut self, input_ty: SignfulInt, output_ty: Float) -> Self::Item; + fn f32_demote_from_f64(&mut self) -> Self::Item; + fn f64_promote_from_f32(&mut self) -> Self::Item; + fn i32_reinterpret_from_f32(&mut self) -> Self::Item; + fn i64_reinterpret_from_f64(&mut self) -> Self::Item; + fn f32_reinterpret_from_i32(&mut self) -> Self::Item; + fn f64_reinterpret_from_i64(&mut self) -> Self::Item; + fn extend(&mut self, sign: Signedness) -> Self::Item; + fn i_sat_trunc_from_f(&mut self, input_ty: Float, output_ty: SignfulInt) -> Self::Item; + fn memory_init(&mut self, segment: u32) -> Self::Item; + fn data_drop(&mut self, segment: u32) -> Self::Item; + fn memory_copy(&mut self) -> Self::Item; + fn memory_fill(&mut self) -> Self::Item; + fn table_init(&mut self, segment: u32) -> Self::Item; + fn elem_drop(&mut self, segment: u32) -> Self::Item; + fn table_copy(&mut self) -> Self::Item; +} + +/// Type of a control frame. +#[derive(Debug, Clone, PartialEq)] +enum ControlFrameKind { + /// A regular block frame. + /// + /// Can be used for an implicit function block. + Block { + needs_end_label: bool, + }, + Function, + /// Loop frame (branching to the beginning of block). + Loop, + /// True-subblock of if expression. + If { + has_else: bool, + }, +} + +#[derive(Debug, Clone, PartialEq)] +struct ControlFrame { + id: u32, + arguments: u32, + returns: Vec<SignlessType>, + kind: ControlFrameKind, +} + +impl ControlFrame { + fn needs_end_label(&self) -> bool { + match self.kind { + ControlFrameKind::Block { needs_end_label } => needs_end_label, + ControlFrameKind::If { .. } => true, + ControlFrameKind::Loop | ControlFrameKind::Function => false, + } + } + + fn mark_branched_to(&mut self) { + if let ControlFrameKind::Block { needs_end_label } = &mut self.kind { + *needs_end_label = true + } + } + + fn br_target(&self) -> BrTarget<(u32, NameTag)> { + match self.kind { + ControlFrameKind::Loop => BrTarget::Label((self.id, NameTag::Header)), + ControlFrameKind::Function => BrTarget::Return, + ControlFrameKind::Block { .. } | ControlFrameKind::If { .. } => { + BrTarget::Label((self.id, NameTag::End)) + } + } + } +} + +pub struct MicrowasmConv<'a, 'b, M> { + // TODO: Maybe have a `ConvInner` type and have this wrap an `Option` so that + // we can dealloc everything when we've finished emitting + is_done: bool, + consts_to_emit: Option<Vec<Value>>, + stack: Vec<SignlessType>, + internal: OperatorsReader<'a>, + module: &'b M, + current_id: u32, + control_frames: Vec<ControlFrame>, + unreachable: bool, +} + +#[derive(Debug)] +enum SigT { + T, + Concrete(SignlessType), +} + +impl From<SignlessType> for SigT { + fn from(other: SignlessType) -> SigT { + SigT::Concrete(other) + } +} + +#[derive(Debug)] +pub struct OpSig { + input: SmallVec<[SigT; 3]>, + output: SmallVec<[SigT; 3]>, +} + +impl OpSig { + #[inline(always)] + fn new<I0, I1>(input: I0, output: I1) -> Self + where + I0: IntoIterator<Item = SigT>, + I1: IntoIterator<Item = SigT>, + { + OpSig { + input: SmallVec::from_iter(input), + output: SmallVec::from_iter(output), + } + } + + fn none() -> Self { + Self::new(None, None) + } +} + +impl<T> From<&'_ T> for OpSig +where + T: Signature, +{ + fn from(other: &T) -> Self { + OpSig::new( + other + .params() + .iter() + .map(|t| SigT::Concrete(t.to_microwasm_type())), + other + .returns() + .iter() + .map(|t| SigT::Concrete(t.to_microwasm_type())), + ) + } +} + +impl<'a, 'b, M: ModuleContext> MicrowasmConv<'a, 'b, M> +where + for<'any> &'any M::Signature: Into<OpSig>, +{ + pub fn new( + context: &'b M, + params: impl IntoIterator<Item = SignlessType>, + returns: impl IntoIterator<Item = SignlessType>, + reader: &'a FunctionBody, + ) -> Result<Self, Error> { + let locals_reader = reader + .get_locals_reader() + .map_err(|_| Error::Microwasm("Failed to get locals reader".to_string()))?; + let mut locals = Vec::from_iter(params); + let mut consts = Vec::new(); + + for loc in locals_reader { + let (count, ty) = + loc.map_err(|_| Error::Microwasm("Getting local failed".to_string()))?; + let ty = Type::from_wasm(ty) + .map_err(|_| Error::Microwasm("Invalid local type".to_string()))?; + + locals.extend(std::iter::repeat(ty).take(count as _)); + consts.extend( + std::iter::repeat(ty) + .map(Value::default_for_type) + .take(count as _), + ) + } + + let num_locals = locals.len() as _; + + let operators_reader = reader + .get_operators_reader() + .map_err(|_| Error::Microwasm("Failed to get operators reader".to_string()))?; + let mut out = Self { + is_done: false, + stack: locals, + module: context, + consts_to_emit: Some(consts), + internal: operators_reader, + current_id: 0, + control_frames: vec![], + unreachable: false, + }; + + let id = out.next_id(); + out.control_frames.push(ControlFrame { + id, + arguments: num_locals, + returns: returns.into_iter().collect(), + kind: ControlFrameKind::Function, + }); + + Ok(out) + } + + fn op_sig(&self, op: &WasmOperator) -> Result<OpSig, Error> { + use self::SigT::T; + use std::iter::{empty as none, once}; + + #[inline(always)] + fn one<A>(a: A) -> impl IntoIterator<Item = SigT> + where + A: Into<SigT>, + { + once(a.into()) + } + + #[inline(always)] + fn two<A, B>(a: A, b: B) -> impl IntoIterator<Item = SigT> + where + A: Into<SigT>, + B: Into<SigT>, + { + once(a.into()).chain(once(b.into())) + } + + #[inline(always)] + fn three<A, B, C>(a: A, b: B, c: C) -> impl IntoIterator<Item = SigT> + where + A: Into<SigT>, + B: Into<SigT>, + C: Into<SigT>, + { + once(a.into()).chain(once(b.into())).chain(once(c.into())) + } + + macro_rules! sig { + (@iter $a:expr, $b:expr, $c:expr) => { three($a, $b, $c) }; + (@iter $a:expr, $b:expr) => { two($a, $b) }; + (@iter $a:expr) => { one($a) }; + (@iter) => { none() }; + (($($t:expr),*) -> ($($o:expr),*)) => { + OpSig::new(sig!(@iter $($t),*), sig!(@iter $($o),*)) + }; + } + + let o = match op { + WasmOperator::Unreachable => OpSig::none(), + WasmOperator::Nop => OpSig::none(), + + WasmOperator::Block { .. } => OpSig::none(), + WasmOperator::Loop { .. } => OpSig::none(), + WasmOperator::If { .. } => sig!((I32) -> ()), + WasmOperator::Else => OpSig::none(), + WasmOperator::End => OpSig::none(), + + WasmOperator::Br { .. } => OpSig::none(), + WasmOperator::BrIf { .. } => sig!((I32) -> ()), + WasmOperator::BrTable { .. } => sig!((I32) -> ()), + WasmOperator::Return => OpSig::none(), + + WasmOperator::Call { function_index } => { + let func_type = self.module.func_type(*function_index); + func_type.into() + } + WasmOperator::CallIndirect { index, .. } => { + let func_type = self.module.signature(*index); + let mut out = func_type.into(); + out.input.push(I32.into()); + out + } + + WasmOperator::Drop => sig!((T) -> ()), + + // `Select` pops 3 elements and pushes 1 + WasmOperator::Select => sig!((T, T, I32) -> (T)), + + WasmOperator::LocalGet { local_index } => { + let ty = self.stack[*local_index as usize]; + + sig!(() -> (ty)) + } + WasmOperator::LocalSet { local_index } => { + let ty = self.stack[*local_index as usize]; + + sig!((ty) -> ()) + } + WasmOperator::LocalTee { local_index } => { + let ty = self.stack[*local_index as usize]; + + sig!((ty) -> (ty)) + } + + WasmOperator::GlobalGet { global_index } => { + sig!(() -> (self.module.global_type(*global_index).to_microwasm_type())) + } + WasmOperator::GlobalSet { global_index } => { + sig!((self.module.global_type(*global_index).to_microwasm_type()) -> ()) + } + + WasmOperator::F32Load { .. } => sig!((I32) -> (F32)), + WasmOperator::F64Load { .. } => sig!((I32) -> (F64)), + + WasmOperator::I32Load { .. } + | WasmOperator::I32Load8S { .. } + | WasmOperator::I32Load8U { .. } + | WasmOperator::I32Load16S { .. } + | WasmOperator::I32Load16U { .. } => sig!((I32) -> (I32)), + + WasmOperator::I64Load { .. } + | WasmOperator::I64Load8S { .. } + | WasmOperator::I64Load8U { .. } + | WasmOperator::I64Load16S { .. } + | WasmOperator::I64Load16U { .. } + | WasmOperator::I64Load32S { .. } + | WasmOperator::I64Load32U { .. } => sig!((I32) -> (I64)), + + WasmOperator::F32Store { .. } => sig!((I32, F32) -> ()), + WasmOperator::F64Store { .. } => sig!((I32, F64) -> ()), + WasmOperator::I32Store { .. } + | WasmOperator::I32Store8 { .. } + | WasmOperator::I32Store16 { .. } => sig!((I32, I32) -> ()), + WasmOperator::I64Store { .. } + | WasmOperator::I64Store8 { .. } + | WasmOperator::I64Store16 { .. } + | WasmOperator::I64Store32 { .. } => sig!((I32, I64) -> ()), + + WasmOperator::MemorySize { .. } => sig!(() -> (I32)), + WasmOperator::MemoryGrow { .. } => sig!((I32) -> (I32)), + + WasmOperator::I32Const { .. } => sig!(() -> (I32)), + WasmOperator::I64Const { .. } => sig!(() -> (I64)), + WasmOperator::F32Const { .. } => sig!(() -> (F32)), + WasmOperator::F64Const { .. } => sig!(() -> (F64)), + + WasmOperator::RefNull => { + return Err(Error::Microwasm("RefNull unimplemented".to_string())) + } + WasmOperator::RefIsNull => { + return Err(Error::Microwasm("RefIsNull unimplemented".to_string())) + } + + // All comparison operators remove 2 elements and push 1 + WasmOperator::I32Eqz => sig!((I32) -> (I32)), + WasmOperator::I32Eq + | WasmOperator::I32Ne + | WasmOperator::I32LtS + | WasmOperator::I32LtU + | WasmOperator::I32GtS + | WasmOperator::I32GtU + | WasmOperator::I32LeS + | WasmOperator::I32LeU + | WasmOperator::I32GeS + | WasmOperator::I32GeU => sig!((I32, I32) -> (I32)), + + WasmOperator::I64Eqz => sig!((I64) -> (I32)), + WasmOperator::I64Eq + | WasmOperator::I64Ne + | WasmOperator::I64LtS + | WasmOperator::I64LtU + | WasmOperator::I64GtS + | WasmOperator::I64GtU + | WasmOperator::I64LeS + | WasmOperator::I64LeU + | WasmOperator::I64GeS + | WasmOperator::I64GeU => sig!((I64, I64) -> (I32)), + + WasmOperator::F32Eq + | WasmOperator::F32Ne + | WasmOperator::F32Lt + | WasmOperator::F32Gt + | WasmOperator::F32Le + | WasmOperator::F32Ge => sig!((F32, F32) -> (I32)), + + WasmOperator::F64Eq + | WasmOperator::F64Ne + | WasmOperator::F64Lt + | WasmOperator::F64Gt + | WasmOperator::F64Le + | WasmOperator::F64Ge => sig!((F64, F64) -> (I32)), + + WasmOperator::I32Clz | WasmOperator::I32Ctz | WasmOperator::I32Popcnt => { + sig!((I32) -> (I32)) + } + WasmOperator::I64Clz | WasmOperator::I64Ctz | WasmOperator::I64Popcnt => { + sig!((I64) -> (I64)) + } + + WasmOperator::I32Add + | WasmOperator::I32Sub + | WasmOperator::I32Mul + | WasmOperator::I32DivS + | WasmOperator::I32DivU + | WasmOperator::I32RemS + | WasmOperator::I32RemU + | WasmOperator::I32And + | WasmOperator::I32Or + | WasmOperator::I32Xor + | WasmOperator::I32Shl + | WasmOperator::I32ShrS + | WasmOperator::I32ShrU + | WasmOperator::I32Rotl + | WasmOperator::I32Rotr => sig!((I32, I32) -> (I32)), + + WasmOperator::I64Add + | WasmOperator::I64Sub + | WasmOperator::I64Mul + | WasmOperator::I64DivS + | WasmOperator::I64DivU + | WasmOperator::I64RemS + | WasmOperator::I64RemU + | WasmOperator::I64And + | WasmOperator::I64Or + | WasmOperator::I64Xor + | WasmOperator::I64Shl + | WasmOperator::I64ShrS + | WasmOperator::I64ShrU + | WasmOperator::I64Rotl + | WasmOperator::I64Rotr => sig!((I64, I64) -> (I64)), + + WasmOperator::F32Abs + | WasmOperator::F32Neg + | WasmOperator::F32Ceil + | WasmOperator::F32Floor + | WasmOperator::F32Trunc + | WasmOperator::F32Nearest + | WasmOperator::F32Sqrt => sig!((F32) -> (F32)), + + WasmOperator::F64Abs + | WasmOperator::F64Neg + | WasmOperator::F64Ceil + | WasmOperator::F64Floor + | WasmOperator::F64Trunc + | WasmOperator::F64Nearest + | WasmOperator::F64Sqrt => sig!((F64) -> (F64)), + + WasmOperator::F32Add + | WasmOperator::F32Sub + | WasmOperator::F32Mul + | WasmOperator::F32Div + | WasmOperator::F32Min + | WasmOperator::F32Max + | WasmOperator::F32Copysign => sig!((F32, F32) -> (F32)), + + WasmOperator::F64Add + | WasmOperator::F64Sub + | WasmOperator::F64Mul + | WasmOperator::F64Div + | WasmOperator::F64Min + | WasmOperator::F64Max + | WasmOperator::F64Copysign => sig!((F64, F64) -> (F64)), + + WasmOperator::I32WrapI64 => sig!((I64) -> (I32)), + WasmOperator::I32TruncF32S | WasmOperator::I32TruncF32U => sig!((F32) -> (I32)), + WasmOperator::I32TruncF64S | WasmOperator::I32TruncF64U => sig!((F64) -> (I32)), + WasmOperator::I64ExtendI32S | WasmOperator::I64ExtendI32U => sig!((I32) -> (I64)), + WasmOperator::I64TruncF32S | WasmOperator::I64TruncF32U => sig!((F32) -> (I64)), + WasmOperator::I64TruncF64S | WasmOperator::I64TruncF64U => sig!((F64) -> (I64)), + WasmOperator::F32ConvertI32S | WasmOperator::F32ConvertI32U => sig!((I32) -> (F32)), + WasmOperator::F32ConvertI64S | WasmOperator::F32ConvertI64U => sig!((I64) -> (F32)), + WasmOperator::F32DemoteF64 => sig!((F64) -> (F32)), + WasmOperator::F64ConvertI32S | WasmOperator::F64ConvertI32U => sig!((I32) -> (F64)), + WasmOperator::F64ConvertI64S | WasmOperator::F64ConvertI64U => sig!((I64) -> (F64)), + WasmOperator::F64PromoteF32 => sig!((F32) -> (F64)), + WasmOperator::I32ReinterpretF32 => sig!((F32) -> (I32)), + WasmOperator::I64ReinterpretF64 => sig!((F64) -> (I64)), + WasmOperator::F32ReinterpretI32 => sig!((I32) -> (F32)), + WasmOperator::F64ReinterpretI64 => sig!((I64) -> (F64)), + + WasmOperator::I32Extend8S => sig!((I32) -> (I32)), + WasmOperator::I32Extend16S => sig!((I32) -> (I32)), + WasmOperator::I64Extend8S => sig!((I32) -> (I64)), + WasmOperator::I64Extend16S => sig!((I32) -> (I64)), + WasmOperator::I64Extend32S => sig!((I32) -> (I64)), + + _ => return Err(Error::Microwasm("Opcode Unimplemented".to_string())), + }; + Ok(o) + } + + fn next_id(&mut self) -> u32 { + let id = self.current_id; + self.current_id += 1; + id + } + + fn nth_block(&self, n: usize) -> &ControlFrame { + self.control_frames.iter().rev().nth(n).unwrap() + } + + fn nth_block_mut(&mut self, n: usize) -> &mut ControlFrame { + self.control_frames.iter_mut().rev().nth(n).unwrap() + } + + fn function_block(&self) -> &ControlFrame { + self.control_frames.first().unwrap() + } + + fn local_depth(&self, idx: u32) -> i32 { + self.stack.len() as i32 - 1 - idx as i32 + } + + fn apply_op(&mut self, sig: OpSig) -> Result<(), Error> { + let mut ty_param = None; + + for p in sig.input.iter().rev() { + let stack_ty = match self.stack.pop() { + Some(e) => e, + None => return Err(Error::Microwasm("Stack is empty".to_string())), + }; + + let ty = match p { + SigT::T => { + if let Some(t) = ty_param { + t + } else { + ty_param = Some(stack_ty); + stack_ty + } + } + SigT::Concrete(ty) => *ty, + }; + + debug_assert_eq!(ty, stack_ty); + } + + for p in sig.output.into_iter().rev() { + let ty = match p { + SigT::T => match ty_param { + Some(e) => e, + None => return Err(Error::Microwasm("Type parameter was not set".to_string())), + }, + SigT::Concrete(ty) => ty, + }; + self.stack.push(ty); + } + Ok(()) + } + + fn block_params(&self) -> Vec<SignlessType> { + self.stack.clone() + } + + fn block_params_with_wasm_type( + &self, + ty: wasmparser::TypeOrFuncType, + ) -> Result<Vec<SignlessType>, Error> { + let mut out = self.block_params(); + let return_wasm_type = create_returns_from_wasm_type(ty)?; + out.extend(return_wasm_type); + Ok(out) + } +} + +impl<'a, 'b, M: ModuleContext> Iterator for MicrowasmConv<'a, 'b, M> +where + for<'any> &'any M::Signature: Into<OpSig>, +{ + type Item = Result<SmallVec<[OperatorFromWasm; 1]>, Error>; + + fn next(&mut self) -> Option<Result<SmallVec<[OperatorFromWasm; 1]>, Error>> { + macro_rules! to_drop { + ($block:expr) => {{ + let block = &$block; + let first_non_local_depth = block.returns.len() as u32; + + (|| { + let last_non_local_depth = (self.stack.len() as u32) + .checked_sub(1)? + .checked_sub(block.arguments)?; + + if first_non_local_depth <= last_non_local_depth { + Some(first_non_local_depth..=last_non_local_depth) + } else { + None + } + })() + }}; + } + + if self.is_done { + return None; + } + + if let Some(consts) = self.consts_to_emit.take() { + return Some(Ok(consts.into_iter().map(Operator::Const).collect())); + } + + if self.unreachable { + self.unreachable = false; + let mut depth = 0; + + // `if..then..else`/`br_if` means that there may be branches in which + // the instruction that caused us to mark this as unreachable to not + // be executed. Tracking this in the microwasm translation step is + // very complicated so we just do basic code removal here and leave + // the removal of uncalled blocks to the backend. + return Some(Ok(loop { + let op = match self.internal.read() { + Err(e) => return Some(Err(e.into())), + Ok(o) => o, + }; + match op { + WasmOperator::Block { .. } + | WasmOperator::Loop { .. } + | WasmOperator::If { .. } => { + depth += 1; + } + WasmOperator::Else => { + if depth == 0 { + let block = match self.control_frames.last_mut() { + Some(e) => e, + None => { + return Some(Err(Error::Microwasm( + "unreachable Block else Failed".to_string(), + ))) + } + }; + + self.stack.truncate(block.arguments as _); + + if let ControlFrameKind::If { has_else, .. } = &mut block.kind { + *has_else = true; + } + + break smallvec![Operator::Label((block.id, NameTag::Else))]; + } + } + WasmOperator::End => { + if depth == 0 { + let block = match self.control_frames.pop() { + Some(e) => e, + None => { + return Some(Err(Error::Microwasm( + "unreachable Block end Failed".to_string(), + ))) + } + }; + + if self.control_frames.is_empty() { + self.is_done = true; + return None; + } + + self.stack.truncate(block.arguments as _); + self.stack.extend(block.returns); + + let end_label = (block.id, NameTag::End); + + if let ControlFrameKind::If { + has_else: false, .. + } = block.kind + { + break smallvec![ + Operator::Label((block.id, NameTag::Else)), + Operator::Br { + target: BrTarget::Label(end_label), + }, + Operator::Label(end_label), + ]; + } else { + break smallvec![Operator::Label((block.id, NameTag::End))]; + } + } else { + depth -= 1; + } + } + _ => {} + } + })); + } + + let op = match self.internal.read() { + Err(e) => return Some(Err(e.into())), + Ok(o) => o, + }; + + let op_sig = match self.op_sig(&op) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + + match self.apply_op(op_sig) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + + Some(Ok(match op { + WasmOperator::Unreachable => { + self.unreachable = true; + smallvec![Operator::Unreachable] + } + WasmOperator::Nop => smallvec![], + WasmOperator::Block { ty } => { + let id = self.next_id(); + let return_type_wasm = match create_returns_from_wasm_type(ty) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + let block_param_type_wasm = match self.block_params_with_wasm_type(ty) { + Err(e) => return Some(Err(e)), + Ok(o) => o, + }; + self.control_frames.push(ControlFrame { + id, + arguments: self.stack.len() as u32, + returns: return_type_wasm, + kind: ControlFrameKind::Block { + needs_end_label: false, + }, + }); + smallvec![Operator::end(block_param_type_wasm, (id, NameTag::End))] + } + WasmOperator::Loop { ty } => { + let id = self.next_id(); + let return_type_wasm = match create_returns_from_wasm_type(ty) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + let block_param_type_wasm = match self.block_params_with_wasm_type(ty) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + self.control_frames.push(ControlFrame { + id, + arguments: self.stack.len() as u32, + returns: return_type_wasm, + kind: ControlFrameKind::Loop, + }); + let label = (id, NameTag::Header); + smallvec![ + Operator::loop_(self.block_params(), label), + Operator::end(block_param_type_wasm, (id, NameTag::End)), + Operator::Br { + target: BrTarget::Label(label), + }, + Operator::Label(label), + ] + } + WasmOperator::If { ty } => { + let id = self.next_id(); + let return_type_wasm = match create_returns_from_wasm_type(ty) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + let block_param_type_wasm = match self.block_params_with_wasm_type(ty) { + Ok(o) => o, + Err(e) => return Some(Err(e)), + }; + self.control_frames.push(ControlFrame { + id, + arguments: self.stack.len() as u32, + returns: return_type_wasm, + kind: ControlFrameKind::If { has_else: false }, + }); + let (then, else_, end) = ( + (id, NameTag::Header), + (id, NameTag::Else), + (id, NameTag::End), + ); + smallvec![ + Operator::block(self.block_params(), then), + Operator::block(self.block_params(), else_), + Operator::end(block_param_type_wasm, end), + Operator::BrIf { + then: BrTarget::Label(then).into(), + else_: BrTarget::Label(else_).into() + }, + Operator::Label(then), + ] + } + WasmOperator::Else => { + // We don't pop it since we're still in the second block. + let block = match self.control_frames.last() { + Some(e) => e, + None => return Some(Err(Error::Microwasm("Block else Failed".to_string()))), + }; + let to_drop = to_drop!(block); + let block = match self.control_frames.last_mut() { + Some(e) => e, + None => return Some(Err(Error::Microwasm("Block else Failed".to_string()))), + }; + + if let ControlFrameKind::If { has_else, .. } = &mut block.kind { + *has_else = true; + } + + self.stack.truncate(block.arguments as _); + + let label = (block.id, NameTag::Else); + + SmallVec::from_iter( + to_drop + .into_iter() + .map(Operator::Drop) + .chain(iter::once(Operator::Br { + target: BrTarget::Label((block.id, NameTag::End)), + })) + .chain(iter::once(Operator::Label(label))), + ) + } + WasmOperator::End => { + let block = match self.control_frames.pop() { + Some(e) => e, + None => return Some(Err(Error::Microwasm("Block End Failed".to_string()))), + }; + + let to_drop = to_drop!(block); + + self.stack.truncate(block.arguments as _); + self.stack.extend(block.returns.iter().cloned()); + + if let ControlFrameKind::If { + has_else: false, .. + } = block.kind + { + let else_ = (block.id, NameTag::Else); + let end = (block.id, NameTag::End); + + to_drop + .map(Operator::Drop) + .into_iter() + .chain::<SmallVec<[_; 4]>>(smallvec![ + Operator::Br { + target: BrTarget::Label(end), + }, + Operator::Label(else_), + Operator::Br { + target: BrTarget::Label(end), + }, + Operator::Label(end), + ]) + .collect() + } else { + SmallVec::from_iter(if self.control_frames.is_empty() { + self.is_done = true; + + None.into_iter() + .chain(Some(Operator::Br { + target: BrTarget::Return, + })) + .chain(None) + } else if block.needs_end_label() { + let label = (block.id, NameTag::End); + + to_drop + .map(Operator::Drop) + .into_iter() + .chain(Some(Operator::Br { + target: BrTarget::Label(label), + })) + .chain(Some(Operator::Label(label))) + } else { + to_drop + .map(Operator::Drop) + .into_iter() + .chain(None) + .chain(None) + }) + } + } + // TODO: If we're breaking out of the function block we want + // to drop locals too (see code for `WasmOperator::End`) + WasmOperator::Br { relative_depth } => { + self.unreachable = true; + let to_drop = to_drop!(self.nth_block(relative_depth as _)); + + let block = self.nth_block_mut(relative_depth as _); + block.mark_branched_to(); + SmallVec::from_iter(to_drop.into_iter().map(Operator::Drop).chain(iter::once( + Operator::Br { + target: block.br_target(), + }, + ))) + } + WasmOperator::BrIf { relative_depth } => { + let to_drop = to_drop!(self.nth_block(relative_depth as _)); + + let label = (self.next_id(), NameTag::Header); + let params = self.block_params(); + let block = self.nth_block_mut(relative_depth as _); + block.mark_branched_to(); + + smallvec![ + Operator::block(params, label), + Operator::BrIf { + then: BrTargetDrop { + to_drop, + target: block.br_target() + }, + else_: BrTarget::Label(label).into(), + }, + Operator::Label(label), + ] + } + WasmOperator::BrTable { table } => { + self.unreachable = true; + let (entries, default) = match table.read_table() { + Ok(o) => o, + Err(e) => return Some(Err(e.into())), + }; + let targets = entries + .iter() + .map(|depth| { + self.nth_block_mut(*depth as _).mark_branched_to(); + let block = self.nth_block(*depth as _); + + let target = block.br_target(); + BrTargetDrop { + to_drop: to_drop!(block), + target, + } + }) + .collect(); + + self.nth_block_mut(default as _).mark_branched_to(); + + let default = self.nth_block(default as _); + let target = default.br_target(); + let default = BrTargetDrop { + to_drop: to_drop!(default), + target, + }; + + smallvec![Operator::BrTable(BrTable { targets, default })] + } + WasmOperator::Return => { + self.unreachable = true; + + let block = self.function_block(); + let to_drop = to_drop!(block); + + SmallVec::from_iter(to_drop.into_iter().map(Operator::Drop).chain(iter::once( + Operator::Br { + target: block.br_target(), + }, + ))) + } + WasmOperator::Call { function_index } => smallvec![Operator::Call { function_index }], + WasmOperator::CallIndirect { index, table_index } => { + smallvec![Operator::CallIndirect { + type_index: index, + table_index, + }] + } + WasmOperator::Drop => smallvec![Operator::Drop(0..=0)], + WasmOperator::Select => smallvec![Operator::Select], + + WasmOperator::LocalGet { local_index } => { + // `- 1` because we apply the stack difference _before_ this point + let depth = self.local_depth(local_index).checked_sub(1)?; + let depth = match depth.try_into() { + Ok(o) => o, + Err(_) => { + return Some(Err(Error::Microwasm( + "LocalGet - Local out of range".to_string(), + ))) + } + }; + smallvec![Operator::Pick(depth)] + } + WasmOperator::LocalSet { local_index } => { + // `+ 1` because we apply the stack difference _before_ this point + let depth = self.local_depth(local_index).checked_add(1)?; + let depth = match depth.try_into() { + Ok(o) => o, + Err(_) => { + return Some(Err(Error::Microwasm( + "LocalSet - Local out of range".to_string(), + ))) + } + }; + smallvec![Operator::Swap(depth), Operator::Drop(0..=0)] + } + WasmOperator::LocalTee { local_index } => { + // `+ 1` because we `pick` before `swap` + let depth = self.local_depth(local_index).checked_add(1)?; + let depth = match depth.try_into() { + Ok(o) => o, + Err(_) => { + return Some(Err(Error::Microwasm( + "LocalTee - Local out of range".to_string(), + ))) + } + }; + smallvec![ + Operator::Pick(0), + Operator::Swap(depth), + Operator::Drop(0..=0), + ] + } + WasmOperator::GlobalGet { global_index } => { + smallvec![Operator::GlobalGet(global_index)] + } + WasmOperator::GlobalSet { global_index } => { + smallvec![Operator::GlobalSet(global_index)] + } + + WasmOperator::I32Load { memarg } => smallvec![Operator::Load { + ty: I32, + memarg: memarg.into() + }], + WasmOperator::I64Load { memarg } => smallvec![Operator::Load { + ty: I64, + memarg: memarg.into() + }], + WasmOperator::F32Load { memarg } => smallvec![Operator::Load { + ty: F32, + memarg: memarg.into() + }], + WasmOperator::F64Load { memarg } => smallvec![Operator::Load { + ty: F64, + memarg: memarg.into() + }], + WasmOperator::I32Load8S { memarg } => smallvec![Operator::Load8 { + ty: sint::I32, + memarg: memarg.into(), + }], + WasmOperator::I32Load8U { memarg } => smallvec![Operator::Load8 { + ty: sint::U32, + memarg: memarg.into(), + }], + WasmOperator::I32Load16S { memarg } => smallvec![Operator::Load16 { + ty: sint::I32, + memarg: memarg.into(), + }], + WasmOperator::I32Load16U { memarg } => smallvec![Operator::Load16 { + ty: sint::U32, + memarg: memarg.into(), + }], + WasmOperator::I64Load8S { memarg } => smallvec![Operator::Load8 { + ty: sint::I64, + memarg: memarg.into(), + }], + WasmOperator::I64Load8U { memarg } => smallvec![Operator::Load8 { + ty: sint::U64, + memarg: memarg.into(), + }], + WasmOperator::I64Load16S { memarg } => smallvec![Operator::Load16 { + ty: sint::I64, + memarg: memarg.into(), + }], + WasmOperator::I64Load16U { memarg } => smallvec![Operator::Load16 { + ty: sint::U64, + memarg: memarg.into(), + }], + WasmOperator::I64Load32S { memarg } => smallvec![Operator::Load32 { + sign: Signedness::Signed, + memarg: memarg.into(), + }], + WasmOperator::I64Load32U { memarg } => smallvec![Operator::Load32 { + sign: Signedness::Unsigned, + memarg: memarg.into(), + }], + + WasmOperator::I32Store { memarg } => smallvec![Operator::Store { + ty: I32, + memarg: memarg.into() + }], + WasmOperator::I64Store { memarg } => smallvec![Operator::Store { + ty: I64, + memarg: memarg.into() + }], + WasmOperator::F32Store { memarg } => smallvec![Operator::Store { + ty: F32, + memarg: memarg.into() + }], + WasmOperator::F64Store { memarg } => smallvec![Operator::Store { + ty: F64, + memarg: memarg.into() + }], + + WasmOperator::I32Store8 { memarg } => smallvec![Operator::Store8 { + ty: Size::_32, + memarg: memarg.into(), + }], + WasmOperator::I32Store16 { memarg } => smallvec![Operator::Store16 { + ty: Size::_32, + memarg: memarg.into(), + }], + WasmOperator::I64Store8 { memarg } => smallvec![Operator::Store8 { + ty: Size::_64, + memarg: memarg.into(), + }], + WasmOperator::I64Store16 { memarg } => smallvec![Operator::Store16 { + ty: Size::_64, + memarg: memarg.into(), + }], + WasmOperator::I64Store32 { memarg } => smallvec![Operator::Store32 { + memarg: memarg.into() + }], + WasmOperator::MemorySize { reserved } => smallvec![Operator::MemorySize { reserved }], + WasmOperator::MemoryGrow { reserved } => smallvec![Operator::MemoryGrow { reserved }], + WasmOperator::I32Const { value } => smallvec![Operator::Const(Value::I32(value))], + WasmOperator::I64Const { value } => smallvec![Operator::Const(Value::I64(value))], + WasmOperator::F32Const { value } => { + smallvec![Operator::Const(Value::F32(value.into()))] + } + WasmOperator::F64Const { value } => { + smallvec![Operator::Const(Value::F64(value.into()))] + } + WasmOperator::RefNull => { + return Some(Err(Error::Microwasm("RefNull unimplemented".to_string()))) + } + WasmOperator::RefIsNull => { + return Some(Err(Error::Microwasm("RefIsNull unimplemented".to_string()))) + } + WasmOperator::I32Eqz => smallvec![Operator::Eqz(Size::_32)], + WasmOperator::I32Eq => smallvec![Operator::Eq(I32)], + WasmOperator::I32Ne => smallvec![Operator::Ne(I32)], + WasmOperator::I32LtS => smallvec![Operator::Lt(SI32)], + WasmOperator::I32LtU => smallvec![Operator::Lt(SU32)], + WasmOperator::I32GtS => smallvec![Operator::Gt(SI32)], + WasmOperator::I32GtU => smallvec![Operator::Gt(SU32)], + WasmOperator::I32LeS => smallvec![Operator::Le(SI32)], + WasmOperator::I32LeU => smallvec![Operator::Le(SU32)], + WasmOperator::I32GeS => smallvec![Operator::Ge(SI32)], + WasmOperator::I32GeU => smallvec![Operator::Ge(SU32)], + WasmOperator::I64Eqz => smallvec![Operator::Eqz(Size::_64)], + WasmOperator::I64Eq => smallvec![Operator::Eq(I64)], + WasmOperator::I64Ne => smallvec![Operator::Ne(I64)], + WasmOperator::I64LtS => smallvec![Operator::Lt(SI64)], + WasmOperator::I64LtU => smallvec![Operator::Lt(SU64)], + WasmOperator::I64GtS => smallvec![Operator::Gt(SI64)], + WasmOperator::I64GtU => smallvec![Operator::Gt(SU64)], + WasmOperator::I64LeS => smallvec![Operator::Le(SI64)], + WasmOperator::I64LeU => smallvec![Operator::Le(SU64)], + WasmOperator::I64GeS => smallvec![Operator::Ge(SI64)], + WasmOperator::I64GeU => smallvec![Operator::Ge(SU64)], + WasmOperator::F32Eq => smallvec![Operator::Eq(F32)], + WasmOperator::F32Ne => smallvec![Operator::Ne(F32)], + WasmOperator::F32Lt => smallvec![Operator::Lt(SF32)], + WasmOperator::F32Gt => smallvec![Operator::Gt(SF32)], + WasmOperator::F32Le => smallvec![Operator::Le(SF32)], + WasmOperator::F32Ge => smallvec![Operator::Ge(SF32)], + WasmOperator::F64Eq => smallvec![Operator::Eq(F64)], + WasmOperator::F64Ne => smallvec![Operator::Ne(F64)], + WasmOperator::F64Lt => smallvec![Operator::Lt(SF64)], + WasmOperator::F64Gt => smallvec![Operator::Gt(SF64)], + WasmOperator::F64Le => smallvec![Operator::Le(SF64)], + WasmOperator::F64Ge => smallvec![Operator::Ge(SF64)], + WasmOperator::I32Clz => smallvec![Operator::Clz(Size::_32)], + WasmOperator::I32Ctz => smallvec![Operator::Ctz(Size::_32)], + WasmOperator::I32Popcnt => smallvec![Operator::Popcnt(Size::_32)], + WasmOperator::I32Add => smallvec![Operator::Add(I32)], + WasmOperator::I32Sub => smallvec![Operator::Sub(I32)], + WasmOperator::I32Mul => smallvec![Operator::Mul(I32)], + WasmOperator::I32DivS => smallvec![Operator::Div(SI32)], + WasmOperator::I32DivU => smallvec![Operator::Div(SU32)], + // Unlike Wasm, our `rem_s` instruction _does_ trap on `-1`. Instead + // of handling this complexity in the backend, we handle it here + // (where it's way easier to debug). + WasmOperator::I32RemS => smallvec![Operator::Rem(sint::I32),], + + WasmOperator::I32RemU => smallvec![Operator::Rem(sint::U32),], + WasmOperator::I32And => smallvec![Operator::And(Size::_32)], + WasmOperator::I32Or => smallvec![Operator::Or(Size::_32)], + WasmOperator::I32Xor => smallvec![Operator::Xor(Size::_32)], + WasmOperator::I32Shl => smallvec![Operator::Shl(Size::_32)], + WasmOperator::I32ShrS => smallvec![Operator::Shr(sint::I32)], + WasmOperator::I32ShrU => smallvec![Operator::Shr(sint::U32)], + WasmOperator::I32Rotl => smallvec![Operator::Rotl(Size::_32)], + WasmOperator::I32Rotr => smallvec![Operator::Rotr(Size::_32)], + WasmOperator::I64Clz => smallvec![Operator::Clz(Size::_64)], + WasmOperator::I64Ctz => smallvec![Operator::Ctz(Size::_64)], + WasmOperator::I64Popcnt => smallvec![Operator::Popcnt(Size::_64)], + WasmOperator::I64Add => smallvec![Operator::Add(I64)], + WasmOperator::I64Sub => smallvec![Operator::Sub(I64)], + WasmOperator::I64Mul => smallvec![Operator::Mul(I64)], + WasmOperator::I64DivS => smallvec![Operator::Div(SI64)], + WasmOperator::I64DivU => smallvec![Operator::Div(SU64)], + WasmOperator::I64RemS => smallvec![Operator::Rem(sint::I64),], + + WasmOperator::I64RemU => smallvec![Operator::Rem(sint::U64)], + WasmOperator::I64And => smallvec![Operator::And(Size::_64)], + WasmOperator::I64Or => smallvec![Operator::Or(Size::_64)], + WasmOperator::I64Xor => smallvec![Operator::Xor(Size::_64)], + WasmOperator::I64Shl => smallvec![Operator::Shl(Size::_64)], + WasmOperator::I64ShrS => smallvec![Operator::Shr(sint::I64)], + WasmOperator::I64ShrU => smallvec![Operator::Shr(sint::U64)], + WasmOperator::I64Rotl => smallvec![Operator::Rotl(Size::_64)], + WasmOperator::I64Rotr => smallvec![Operator::Rotr(Size::_64)], + WasmOperator::F32Abs => smallvec![Operator::Abs(Size::_32)], + WasmOperator::F32Neg => smallvec![Operator::Neg(Size::_32)], + WasmOperator::F32Ceil => smallvec![Operator::Ceil(Size::_32)], + WasmOperator::F32Floor => smallvec![Operator::Floor(Size::_32)], + WasmOperator::F32Trunc => smallvec![Operator::Trunc(Size::_32)], + WasmOperator::F32Nearest => smallvec![Operator::Nearest(Size::_32)], + WasmOperator::F32Sqrt => smallvec![Operator::Sqrt(Size::_32)], + WasmOperator::F32Add => smallvec![Operator::Add(F32)], + WasmOperator::F32Sub => smallvec![Operator::Sub(F32)], + WasmOperator::F32Mul => smallvec![Operator::Mul(F32)], + WasmOperator::F32Div => smallvec![Operator::Div(SF32)], + WasmOperator::F32Min => smallvec![Operator::Min(Size::_32)], + WasmOperator::F32Max => smallvec![Operator::Max(Size::_32)], + WasmOperator::F32Copysign => smallvec![Operator::Copysign(Size::_32)], + WasmOperator::F64Abs => smallvec![Operator::Abs(Size::_64)], + WasmOperator::F64Neg => smallvec![Operator::Neg(Size::_64)], + WasmOperator::F64Ceil => smallvec![Operator::Ceil(Size::_64)], + WasmOperator::F64Floor => smallvec![Operator::Floor(Size::_64)], + WasmOperator::F64Trunc => smallvec![Operator::Trunc(Size::_64)], + WasmOperator::F64Nearest => smallvec![Operator::Nearest(Size::_64)], + WasmOperator::F64Sqrt => smallvec![Operator::Sqrt(Size::_64)], + WasmOperator::F64Add => smallvec![Operator::Add(F64)], + WasmOperator::F64Sub => smallvec![Operator::Sub(F64)], + WasmOperator::F64Mul => smallvec![Operator::Mul(F64)], + WasmOperator::F64Div => smallvec![Operator::Div(SF64)], + WasmOperator::F64Min => smallvec![Operator::Min(Size::_64)], + WasmOperator::F64Max => smallvec![Operator::Max(Size::_64)], + WasmOperator::F64Copysign => smallvec![Operator::Copysign(Size::_64)], + WasmOperator::I32WrapI64 => smallvec![Operator::I32WrapFromI64], + WasmOperator::I32TruncF32S => smallvec![Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::I32 + }], + WasmOperator::I32TruncF32U => smallvec![Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::U32 + }], + WasmOperator::I32TruncF64S => smallvec![Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::I32 + }], + WasmOperator::I32TruncF64U => smallvec![Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::U32 + }], + WasmOperator::I64ExtendI32S => smallvec![Operator::Extend { + sign: Signedness::Signed + }], + WasmOperator::I64ExtendI32U => smallvec![Operator::Extend { + sign: Signedness::Unsigned + }], + WasmOperator::I64TruncF32S => smallvec![Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::I64, + }], + WasmOperator::I64TruncF32U => smallvec![Operator::ITruncFromF { + input_ty: Size::_32, + output_ty: sint::U64, + }], + WasmOperator::I64TruncF64S => smallvec![Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::I64, + }], + WasmOperator::I64TruncF64U => smallvec![Operator::ITruncFromF { + input_ty: Size::_64, + output_ty: sint::U64, + }], + WasmOperator::F32ConvertI32S => smallvec![Operator::FConvertFromI { + input_ty: sint::I32, + output_ty: Size::_32 + }], + WasmOperator::F32ConvertI32U => smallvec![Operator::FConvertFromI { + input_ty: sint::U32, + output_ty: Size::_32 + }], + WasmOperator::F32ConvertI64S => smallvec![Operator::FConvertFromI { + input_ty: sint::I64, + output_ty: Size::_32 + }], + WasmOperator::F32ConvertI64U => smallvec![Operator::FConvertFromI { + input_ty: sint::U64, + output_ty: Size::_32 + }], + WasmOperator::F64ConvertI32S => smallvec![Operator::FConvertFromI { + input_ty: sint::I32, + output_ty: Size::_64 + }], + WasmOperator::F64ConvertI32U => smallvec![Operator::FConvertFromI { + input_ty: sint::U32, + output_ty: Size::_64 + }], + WasmOperator::F64ConvertI64S => smallvec![Operator::FConvertFromI { + input_ty: sint::I64, + output_ty: Size::_64 + }], + WasmOperator::F64ConvertI64U => smallvec![Operator::FConvertFromI { + input_ty: sint::U64, + output_ty: Size::_64 + }], + WasmOperator::F32DemoteF64 => smallvec![Operator::F32DemoteFromF64], + WasmOperator::F64PromoteF32 => smallvec![Operator::F64PromoteFromF32], + WasmOperator::I32ReinterpretF32 => smallvec![Operator::I32ReinterpretFromF32], + WasmOperator::I64ReinterpretF64 => smallvec![Operator::I64ReinterpretFromF64], + WasmOperator::F32ReinterpretI32 => smallvec![Operator::F32ReinterpretFromI32], + WasmOperator::F64ReinterpretI64 => smallvec![Operator::F64ReinterpretFromI64], + WasmOperator::I32Extend8S => { + return Some(Err(Error::Microwasm( + "I32Extend8S unimplemented".to_string(), + ))) + } + WasmOperator::I32Extend16S => { + return Some(Err(Error::Microwasm( + "I32Extend16S unimplemented".to_string(), + ))) + } + WasmOperator::I64Extend8S => { + return Some(Err(Error::Microwasm( + "I64Extend8S unimplemented".to_string(), + ))) + } + WasmOperator::I64Extend16S => { + return Some(Err(Error::Microwasm( + "I64Extend16S unimplemented".to_string(), + ))) + } + WasmOperator::I64Extend32S => { + return Some(Err(Error::Microwasm( + "I64Extend32S unimplemented".to_string(), + ))) + } + + // 0xFC operators + // Non-trapping Float-to-int Conversions + WasmOperator::I32TruncSatF32S => { + return Some(Err(Error::Microwasm( + "I32TruncSatF32S unimplemented".to_string(), + ))) + } + WasmOperator::I32TruncSatF32U => { + return Some(Err(Error::Microwasm( + "I32TruncSatF32U unimplemented".to_string(), + ))) + } + WasmOperator::I32TruncSatF64S => { + return Some(Err(Error::Microwasm( + "I32TruncSatF64S unimplemented".to_string(), + ))) + } + WasmOperator::I32TruncSatF64U => { + return Some(Err(Error::Microwasm( + "I32TruncSatF64U unimplemented".to_string(), + ))) + } + WasmOperator::I64TruncSatF32S => { + return Some(Err(Error::Microwasm( + "I64TruncSatF32S unimplemented".to_string(), + ))) + } + WasmOperator::I64TruncSatF32U => { + return Some(Err(Error::Microwasm( + "I64TruncSatF32U unimplemented".to_string(), + ))) + } + WasmOperator::I64TruncSatF64S => { + return Some(Err(Error::Microwasm( + "I64TruncSatF64S unimplemented".to_string(), + ))) + } + WasmOperator::I64TruncSatF64U => { + return Some(Err(Error::Microwasm( + "I64TruncSatF64U unimplemented".to_string(), + ))) + } + + _other => return Some(Err(Error::Microwasm("Opcode unimplemented".to_string()))), + })) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +
+use crate::backend::TranslatedCodeSection; +use crate::error::Error; +use crate::microwasm; +use crate::translate_sections; +use cranelift_codegen::{ + ir::{self, AbiParam, Signature as CraneliftSignature}, + isa, +}; +use memoffset::offset_of; + +use std::{convert::TryInto, mem}; +use thiserror::Error; +use wasmparser::{FuncType, MemoryType, ModuleReader, SectionCode, Type}; + +pub trait AsValueType { + const TYPE: Type; +} + +pub trait TypeList { + const TYPE_LIST: &'static [Type]; +} + +impl<T> TypeList for T +where + T: AsValueType, +{ + const TYPE_LIST: &'static [Type] = &[T::TYPE]; +} + +impl AsValueType for i32 { + const TYPE: Type = Type::I32; +} +impl AsValueType for i64 { + const TYPE: Type = Type::I64; +} +impl AsValueType for u32 { + const TYPE: Type = Type::I32; +} +impl AsValueType for u64 { + const TYPE: Type = Type::I64; +} +impl AsValueType for f32 { + const TYPE: Type = Type::F32; +} +impl AsValueType for f64 { + const TYPE: Type = Type::F64; +} + +pub trait FunctionArgs<O> { + type FuncType; + + unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> O; + fn into_func(start: *const u8) -> Self::FuncType; +} + +type VmCtxPtr = u64; + +macro_rules! impl_function_args { + ($first:ident $(, $rest:ident)*) => { + impl<Output, $first, $($rest),*> FunctionArgs<Output> for ($first, $($rest),*) { + type FuncType = unsafe extern "sysv64" fn(VmCtxPtr, $first $(, $rest)*) -> Output; + + #[allow(non_snake_case)] + unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> Output { + let ($first, $($rest),*) = self; + func(vm_ctx as VmCtxPtr, $first $(, $rest)*) + } + + fn into_func(start: *const u8) -> Self::FuncType { + unsafe { mem::transmute(start) } + } + } + + impl<$first: AsValueType, $($rest: AsValueType),*> TypeList for ($first, $($rest),*) { + const TYPE_LIST: &'static [Type] = &[$first::TYPE, $($rest::TYPE),*]; + } + + impl_function_args!($($rest),*); + }; + () => { + impl<Output> FunctionArgs<Output> for () { + type FuncType = unsafe extern "sysv64" fn(VmCtxPtr) -> Output; + + unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> Output { + func(vm_ctx as VmCtxPtr) + } + + fn into_func(start: *const u8) -> Self::FuncType { + unsafe { mem::transmute(start) } + } + } + + impl TypeList for () { + const TYPE_LIST: &'static [Type] = &[]; + } + }; +} + +impl_function_args!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S); + +#[derive(Default)] +pub struct TranslatedModule { + translated_code_section: Option<TranslatedCodeSection>, + ctx: SimpleContext, + // TODO: Should we wrap this in a `Mutex` so that calling functions from multiple + // threads doesn't cause data races? + memory: Option<MemoryType>, +} + +impl TranslatedModule { + pub fn instantiate(self) -> ExecutableModule { + let mem_size = self.memory.map(|m| m.limits.initial).unwrap_or(0) as usize; + let mem: BoxSlice<_> = vec![0u8; mem_size * WASM_PAGE_SIZE] + .into_boxed_slice() + .into(); + + let ctx = if mem.len > 0 { + Some(Box::new(VmCtx { mem }) as Box<VmCtx>) + } else { + None + }; + + ExecutableModule { + module: self, + context: ctx, + } + } + + pub fn disassemble(&self) { + self.translated_code_section + .as_ref() + .expect("no code section") + .disassemble(); + } +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Error)] +pub enum ExecutionError { + #[error("function index out of bounds")] + FuncIndexOutOfBounds, + #[error("type mismatch")] + TypeMismatch, +} + +pub struct ExecutableModule { + module: TranslatedModule, + context: Option<Box<VmCtx>>, +} + +impl ExecutableModule { + /// Executes the function identified by `func_idx`. + /// + /// # Safety + /// + /// Executes the function _without_ checking the argument types. + /// This can cause undefined memory to be accessed. + pub unsafe fn execute_func_unchecked<Args: FunctionArgs<T>, T>( + &self, + func_idx: u32, + args: Args, + ) -> T { + let code_section = self + .module + .translated_code_section + .as_ref() + .expect("no code section"); + let start_buf = code_section.func_start(func_idx as usize); + + args.call( + Args::into_func(start_buf), + self.context + .as_ref() + .map(|ctx| (&**ctx) as *const VmCtx as *const u8) + .unwrap_or(std::ptr::null()), + ) + } + + pub fn execute_func<Args: FunctionArgs<T> + TypeList, T: TypeList>( + &self, + func_idx: u32, + args: Args, + ) -> Result<T, ExecutionError> { + let module = &self.module; + + if func_idx as usize >= module.ctx.func_ty_indicies.len() { + return Err(ExecutionError::FuncIndexOutOfBounds); + } + + let type_ = module.ctx.func_type(func_idx); + + // TODO: Handle "compatible" types (i.e. f32 and i32) + if (&type_.params[..], &type_.returns[..]) != (Args::TYPE_LIST, T::TYPE_LIST) { + return Err(ExecutionError::TypeMismatch); + } + + Ok(unsafe { self.execute_func_unchecked(func_idx, args) }) + } + + pub fn disassemble(&self) { + self.module.disassemble(); + } +} + +struct BoxSlice<T> { + len: usize, + ptr: *mut T, +} + +impl<T> From<Box<[T]>> for BoxSlice<T> { + fn from(mut other: Box<[T]>) -> Self { + let out = BoxSlice { + len: other.len(), + ptr: other.as_mut_ptr(), + }; + mem::forget(other); + out + } +} + +unsafe impl<T: Send> Send for BoxSlice<T> {} +unsafe impl<T: Sync> Sync for BoxSlice<T> {} + +impl<T> Drop for BoxSlice<T> { + fn drop(&mut self) { + unsafe { Vec::from_raw_parts(self.ptr, self.len, self.len) }; + } +} + +type BoxByteSlice = BoxSlice<u8>; + +pub struct VmCtx { + mem: BoxByteSlice, +} + +impl VmCtx { + pub fn offset_of_memory_ptr() -> u32 { + (offset_of!(VmCtx, mem) + offset_of!(BoxByteSlice, ptr)) + .try_into() + .expect("Offset exceeded size of u32") + } + + pub fn offset_of_memory_len() -> u32 { + (offset_of!(VmCtx, mem) + offset_of!(BoxByteSlice, len)) + .try_into() + .expect("Offset exceeded size of u32") + } +} + +#[derive(Default, Debug)] +pub struct SimpleContext { + types: Vec<FuncType>, + func_ty_indicies: Vec<u32>, +} + +pub const WASM_PAGE_SIZE: usize = 65_536; + +pub trait Signature { + type Type: SigType; + + fn params(&self) -> &[Self::Type]; + fn returns(&self) -> &[Self::Type]; +} + +pub trait SigType { + fn to_microwasm_type(&self) -> microwasm::SignlessType; +} + +impl SigType for ir::Type { + fn to_microwasm_type(&self) -> microwasm::SignlessType { + use crate::microwasm::{Size::*, Type::*}; + + if self.is_int() { + match self.bits() { + 32 => Int(_32), + 64 => Int(_64), + _ => unimplemented!(), + } + } else if self.is_float() { + match self.bits() { + 32 => Float(_32), + 64 => Float(_64), + _ => unimplemented!(), + } + } else { + unimplemented!() + } + } +} + +impl SigType for AbiParam { + fn to_microwasm_type(&self) -> microwasm::SignlessType { + self.value_type.to_microwasm_type() + } +} + +impl Signature for CraneliftSignature { + type Type = AbiParam; + + fn params(&self) -> &[Self::Type] { + // TODO: We want to instead add the `VMContext` to the signature used by + // cranelift, removing the special-casing from the internals. + assert_eq!(self.params[0].purpose, ir::ArgumentPurpose::VMContext); + assert_eq!(self.call_conv, isa::CallConv::SystemV); + &self.params[1..] + } + + fn returns(&self) -> &[Self::Type] { + assert_eq!(self.call_conv, isa::CallConv::SystemV); + &self.returns + } +} + +impl SigType for wasmparser::Type { + fn to_microwasm_type(&self) -> microwasm::SignlessType { + microwasm::Type::from_wasm(*self).unwrap() + } +} + +impl Signature for FuncType { + type Type = wasmparser::Type; + + fn params(&self) -> &[Self::Type] { + &*self.params + } + + fn returns(&self) -> &[Self::Type] { + &*self.returns + } +} + +pub trait ModuleContext { + type Signature: Signature; + type GlobalType: SigType; + + fn vmctx_vmglobal_definition(&self, index: u32) -> u32; + fn vmctx_vmglobal_import_from(&self, index: u32) -> u32; + fn vmctx_vmmemory_import_from(&self, memory_index: u32) -> u32; + fn vmctx_vmmemory_definition(&self, defined_memory_index: u32) -> u32; + fn vmctx_vmmemory_definition_base(&self, defined_memory_index: u32) -> u32; + fn vmctx_vmmemory_definition_current_length(&self, defined_memory_index: u32) -> u32; + fn vmmemory_definition_base(&self) -> u8; + fn vmmemory_definition_current_length(&self) -> u8; + fn vmctx_vmtable_import_from(&self, table_index: u32) -> u32; + fn vmctx_vmtable_definition(&self, defined_table_index: u32) -> u32; + fn vmctx_vmtable_definition_base(&self, defined_table_index: u32) -> u32; + fn vmctx_vmtable_definition_current_elements(&self, defined_table_index: u32) -> u32; + fn vmctx_vmfunction_import_body(&self, func_index: u32) -> u32; + fn vmctx_vmfunction_import_vmctx(&self, func_index: u32) -> u32; + fn vmtable_definition_base(&self) -> u8; + fn vmtable_definition_current_elements(&self) -> u8; + fn vmctx_vmshared_signature_id(&self, signature_idx: u32) -> u32; + fn vmcaller_checked_anyfunc_type_index(&self) -> u8; + fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8; + fn vmcaller_checked_anyfunc_vmctx(&self) -> u8; + fn size_of_vmcaller_checked_anyfunc(&self) -> u8; + + fn defined_table_index(&self, table_index: u32) -> Option<u32>; + fn defined_memory_index(&self, index: u32) -> Option<u32>; + + fn defined_global_index(&self, global_index: u32) -> Option<u32>; + fn global_type(&self, global_index: u32) -> &Self::GlobalType; + + fn func_type_index(&self, func_idx: u32) -> u32; + fn signature(&self, index: u32) -> &Self::Signature; + + fn func_index(&self, defined_func_index: u32) -> u32; + fn defined_func_index(&self, func_index: u32) -> Option<u32>; + + fn defined_func_type(&self, defined_func_idx: u32) -> &Self::Signature { + self.func_type(self.func_index(defined_func_idx)) + } + + fn func_type(&self, func_idx: u32) -> &Self::Signature { + self.signature(self.func_type_index(func_idx)) + } + + fn emit_memory_bounds_check(&self) -> bool { + true + } +} + +impl ModuleContext for SimpleContext { + type Signature = FuncType; + type GlobalType = wasmparser::Type; + + // TODO: We don't support external functions yet + fn func_index(&self, func_idx: u32) -> u32 { + func_idx + } + + fn defined_func_index(&self, func_idx: u32) -> Option<u32> { + Some(func_idx) + } + + fn func_type_index(&self, func_idx: u32) -> u32 { + self.func_ty_indicies[func_idx as usize] + } + + fn defined_global_index(&self, _index: u32) -> Option<u32> { + unimplemented!() + } + + fn global_type(&self, _global_index: u32) -> &Self::GlobalType { + unimplemented!() + } + + fn signature(&self, index: u32) -> &Self::Signature { + &self.types[index as usize] + } + + fn vmctx_vmglobal_definition(&self, _index: u32) -> u32 { + unimplemented!() + } + + fn vmctx_vmglobal_import_from(&self, _index: u32) -> u32 { + unimplemented!() + } + + fn defined_memory_index(&self, _index: u32) -> Option<u32> { + unimplemented!() + } + + fn defined_table_index(&self, index: u32) -> Option<u32> { + Some(index) + } + + fn vmctx_vmfunction_import_body(&self, _func_index: u32) -> u32 { + unimplemented!() + } + fn vmctx_vmfunction_import_vmctx(&self, _func_index: u32) -> u32 { + unimplemented!() + } + + fn vmctx_vmtable_import_from(&self, _table_index: u32) -> u32 { + unimplemented!() + } + + fn vmctx_vmmemory_definition(&self, _defined_memory_index: u32) -> u32 { + unimplemented!() + } + fn vmctx_vmmemory_import_from(&self, _memory_index: u32) -> u32 { + unimplemented!() + } + fn vmmemory_definition_base(&self) -> u8 { + unimplemented!() + } + fn vmmemory_definition_current_length(&self) -> u8 { + unimplemented!() + } + fn vmctx_vmmemory_definition_base(&self, defined_memory_index: u32) -> u32 { + assert_eq!(defined_memory_index, 0); + VmCtx::offset_of_memory_ptr() + } + + fn vmctx_vmmemory_definition_current_length(&self, defined_memory_index: u32) -> u32 { + assert_eq!(defined_memory_index, 0); + VmCtx::offset_of_memory_len() + } + + fn vmctx_vmtable_definition(&self, _defined_table_index: u32) -> u32 { + unimplemented!() + } + + fn vmctx_vmtable_definition_base(&self, _defined_table_index: u32) -> u32 { + unimplemented!() + } + + fn vmctx_vmtable_definition_current_elements(&self, _defined_table_index: u32) -> u32 { + unimplemented!() + } + + fn vmtable_definition_base(&self) -> u8 { + unimplemented!() + } + + fn vmtable_definition_current_elements(&self) -> u8 { + unimplemented!() + } + + fn vmcaller_checked_anyfunc_vmctx(&self) -> u8 { + unimplemented!() + } + + fn vmcaller_checked_anyfunc_type_index(&self) -> u8 { + unimplemented!() + } + + fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8 { + unimplemented!() + } + + fn size_of_vmcaller_checked_anyfunc(&self) -> u8 { + unimplemented!() + } + + fn vmctx_vmshared_signature_id(&self, _signature_idx: u32) -> u32 { + unimplemented!() + } + + // TODO: type of a global +} + +pub fn translate(data: &[u8]) -> Result<ExecutableModule, Error> { + translate_only(data).map(|m| m.instantiate()) +} + +/// Translate from a slice of bytes holding a wasm module. +pub fn translate_only(data: &[u8]) -> Result<TranslatedModule, Error> { + let mut reader = ModuleReader::new(data)?; + let mut output = TranslatedModule::default(); + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + let mut section = reader.read()?; + + if let SectionCode::Type = section.code { + let types_reader = section.get_type_section_reader()?; + output.ctx.types = translate_sections::type_(types_reader)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Import = section.code { + let imports = section.get_import_section_reader()?; + translate_sections::import(imports)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Function = section.code { + let functions = section.get_function_section_reader()?; + output.ctx.func_ty_indicies = translate_sections::function(functions)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Table = section.code { + let tables = section.get_table_section_reader()?; + translate_sections::table(tables)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Memory = section.code { + let memories = section.get_memory_section_reader()?; + let mem = translate_sections::memory(memories)?; + + if mem.len() > 1 { + return Err(Error::Input( + "Multiple memory sections not yet implemented".to_string(), + )); + } + + if !mem.is_empty() { + let mem = mem[0]; + if Some(mem.limits.initial) != mem.limits.maximum { + return Err(Error::Input( + "Custom memory limits not supported in lightbeam".to_string(), + )); + } + output.memory = Some(mem); + } + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Global = section.code { + let globals = section.get_global_section_reader()?; + translate_sections::global(globals)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Export = section.code { + let exports = section.get_export_section_reader()?; + translate_sections::export(exports)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Start = section.code { + let start = section.get_start_section_content()?; + translate_sections::start(start)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Element = section.code { + let elements = section.get_element_section_reader()?; + translate_sections::element(elements)?; + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Code = section.code { + let code = section.get_code_section_reader()?; + output.translated_code_section = Some(translate_sections::code(code, &output.ctx)?); + + reader.skip_custom_sections()?; + if reader.eof() { + return Ok(output); + } + section = reader.read()?; + } + + if let SectionCode::Data = section.code { + let data = section.get_data_section_reader()?; + translate_sections::data(data)?; + } + + if !reader.eof() { + return Err(Error::Input( + "Unexpected data found after the end of the module".to_string(), + )); + } + + Ok(output) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +
+use crate::backend::{CodeGenSession, TranslatedCodeSection}; +use crate::error::Error; +use crate::function_body; +use crate::module::SimpleContext; +use cranelift_codegen::{binemit, ir}; +use wasmparser::{ + CodeSectionReader, DataSectionReader, ElementSectionReader, ExportSectionReader, FuncType, + FunctionSectionReader, GlobalSectionReader, ImportSectionReader, MemorySectionReader, + MemoryType, TableSectionReader, TableType, TypeSectionReader, +}; + +/// Parses the Type section of the wasm module. +pub fn type_(types_reader: TypeSectionReader) -> Result<Vec<FuncType>, Error> { + types_reader + .into_iter() + .map(|r| r.map_err(Into::into)) + .collect() +} + +/// Parses the Import section of the wasm module. +pub fn import(imports: ImportSectionReader) -> Result<(), Error> { + for entry in imports { + entry?; // TODO + } + Ok(()) +} + +/// Parses the Function section of the wasm module. +pub fn function(functions: FunctionSectionReader) -> Result<Vec<u32>, Error> { + functions + .into_iter() + .map(|r| r.map_err(Into::into)) + .collect() +} + +/// Parses the Table section of the wasm module. +pub fn table(tables: TableSectionReader) -> Result<Vec<TableType>, Error> { + tables.into_iter().map(|r| r.map_err(Into::into)).collect() +} + +/// Parses the Memory section of the wasm module. +pub fn memory(memories: MemorySectionReader) -> Result<Vec<MemoryType>, Error> { + memories + .into_iter() + .map(|r| r.map_err(Into::into)) + .collect() +} + +/// Parses the Global section of the wasm module. +pub fn global(globals: GlobalSectionReader) -> Result<(), Error> { + for entry in globals { + entry?; // TODO + } + Ok(()) +} + +/// Parses the Export section of the wasm module. +pub fn export(exports: ExportSectionReader) -> Result<(), Error> { + for entry in exports { + entry?; // TODO + } + Ok(()) +} + +/// Parses the Start section of the wasm module. +pub fn start(_index: u32) -> Result<(), Error> { + // TODO + Ok(()) +} + +/// Parses the Element section of the wasm module. +pub fn element(elements: ElementSectionReader) -> Result<(), Error> { + for entry in elements { + entry?; + } + + Ok(()) +} + +struct UnimplementedRelocSink; + +impl binemit::RelocSink for UnimplementedRelocSink { + fn reloc_block(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: binemit::CodeOffset) { + unimplemented!() + } + + fn reloc_external( + &mut self, + _: binemit::CodeOffset, + _: binemit::Reloc, + _: &ir::ExternalName, + _: binemit::Addend, + ) { + unimplemented!() + } + + fn reloc_constant(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: ir::ConstantOffset) { + unimplemented!() + } + + fn reloc_jt(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: ir::JumpTable) { + unimplemented!() + } +} + +/// Parses the Code section of the wasm module. +pub fn code( + code: CodeSectionReader, + translation_ctx: &SimpleContext, +) -> Result<TranslatedCodeSection, Error> { + let func_count = code.get_count(); + let mut session = CodeGenSession::new(func_count, translation_ctx); + + for (idx, body) in code.into_iter().enumerate() { + let body = body?; + let mut relocs = UnimplementedRelocSink; + + function_body::translate_wasm(&mut session, &mut relocs, idx as u32, &body)?; + } + + Ok(session.into_translated_code_section()?) +} + +/// Parses the Data section of the wasm module. +pub fn data(data: DataSectionReader) -> Result<(), Error> { + for entry in data { + entry?; // TODO + } + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +
+use crate::fdentry::FdEntry; +use crate::{wasi, Error, Result}; +use std::borrow::Borrow; +use std::collections::HashMap; +use std::env; +use std::ffi::{CString, OsString}; +use std::fs::File; +use std::path::{Path, PathBuf}; + +enum PendingFdEntry { + Thunk(fn() -> Result<FdEntry>), + File(File), +} + +impl std::fmt::Debug for PendingFdEntry { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Thunk(f) => write!( + fmt, + "PendingFdEntry::Thunk({:p})", + f as *const fn() -> Result<FdEntry> + ), + Self::File(f) => write!(fmt, "PendingFdEntry::File({:?})", f), + } + } +} + +#[derive(Debug, Eq, Hash, PartialEq)] +enum PendingCString { + Bytes(Vec<u8>), + OsString(OsString), +} + +impl From<Vec<u8>> for PendingCString { + fn from(bytes: Vec<u8>) -> Self { + Self::Bytes(bytes) + } +} + +impl From<OsString> for PendingCString { + fn from(s: OsString) -> Self { + Self::OsString(s) + } +} + +impl PendingCString { + fn into_string(self) -> Result<String> { + match self { + Self::Bytes(v) => String::from_utf8(v).map_err(|_| Error::EILSEQ), + Self::OsString(s) => s.into_string().map_err(|_| Error::EILSEQ), + } + } + + /// Create a `CString` containing valid UTF-8, or fail with `Error::EILSEQ`. + fn into_utf8_cstring(self) -> Result<CString> { + self.into_string() + .and_then(|s| CString::new(s).map_err(|_| Error::EILSEQ)) + } +} + +/// A builder allowing customizable construction of `WasiCtx` instances. +pub struct WasiCtxBuilder { + fds: HashMap<wasi::__wasi_fd_t, PendingFdEntry>, + preopens: Vec<(PathBuf, File)>, + args: Vec<PendingCString>, + env: HashMap<PendingCString, PendingCString>, +} + +impl WasiCtxBuilder { + /// Builder for a new `WasiCtx`. + pub fn new() -> Self { + let mut builder = Self { + fds: HashMap::new(), + preopens: Vec::new(), + args: vec![], + env: HashMap::new(), + }; + + builder.fds.insert(0, PendingFdEntry::Thunk(FdEntry::null)); + builder.fds.insert(1, PendingFdEntry::Thunk(FdEntry::null)); + builder.fds.insert(2, PendingFdEntry::Thunk(FdEntry::null)); + + builder + } + + /// Add arguments to the command-line arguments list. + /// + /// Arguments must be valid UTF-8 with no NUL bytes, or else `WasiCtxBuilder::build()` will fail + /// with `Error::EILSEQ`. + pub fn args<S: AsRef<[u8]>>(mut self, args: impl IntoIterator<Item = S>) -> Self { + self.args = args + .into_iter() + .map(|arg| arg.as_ref().to_vec().into()) + .collect(); + self + } + + /// Add an argument to the command-line arguments list. + /// + /// Arguments must be valid UTF-8 with no NUL bytes, or else `WasiCtxBuilder::build()` will fail + /// with `Error::EILSEQ`. + pub fn arg<S: AsRef<[u8]>>(mut self, arg: S) -> Self { + self.args.push(arg.as_ref().to_vec().into()); + self + } + + /// Inherit the command-line arguments from the host process. + /// + /// If any arguments from the host process contain invalid UTF-8, `WasiCtxBuilder::build()` will + /// fail with `Error::EILSEQ`. + pub fn inherit_args(mut self) -> Self { + self.args = env::args_os().map(PendingCString::OsString).collect(); + self + } + + /// Inherit the stdin, stdout, and stderr streams from the host process. + pub fn inherit_stdio(mut self) -> Self { + self.fds + .insert(0, PendingFdEntry::Thunk(FdEntry::duplicate_stdin)); + self.fds + .insert(1, PendingFdEntry::Thunk(FdEntry::duplicate_stdout)); + self.fds + .insert(2, PendingFdEntry::Thunk(FdEntry::duplicate_stderr)); + self + } + + /// Inherit the environment variables from the host process. + /// + /// If any environment variables from the host process contain invalid Unicode (UTF-16 for + /// Windows, UTF-8 for other platforms), `WasiCtxBuilder::build()` will fail with + /// `Error::EILSEQ`. + pub fn inherit_env(mut self) -> Self { + self.env = std::env::vars_os() + .map(|(k, v)| (k.into(), v.into())) + .collect(); + self + } + + /// Add an entry to the environment. + /// + /// Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else + /// `WasiCtxBuilder::build()` will fail with `Error::EILSEQ`. + pub fn env<S: AsRef<[u8]>>(mut self, k: S, v: S) -> Self { + self.env + .insert(k.as_ref().to_vec().into(), v.as_ref().to_vec().into()); + self + } + + /// Add entries to the environment. + /// + /// Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else + /// `WasiCtxBuilder::build()` will fail with `Error::EILSEQ`. + pub fn envs<S: AsRef<[u8]>, T: Borrow<(S, S)>>( + mut self, + envs: impl IntoIterator<Item = T>, + ) -> Self { + self.env = envs + .into_iter() + .map(|t| { + let (k, v) = t.borrow(); + (k.as_ref().to_vec().into(), v.as_ref().to_vec().into()) + }) + .collect(); + self + } + + /// Provide a File to use as stdin + pub fn stdin(mut self, file: File) -> Self { + self.fds.insert(0, PendingFdEntry::File(file)); + self + } + + /// Provide a File to use as stdout + pub fn stdout(mut self, file: File) -> Self { + self.fds.insert(1, PendingFdEntry::File(file)); + self + } + + /// Provide a File to use as stderr + pub fn stderr(mut self, file: File) -> Self { + self.fds.insert(2, PendingFdEntry::File(file)); + self + } + + /// Add a preopened directory. + pub fn preopened_dir<P: AsRef<Path>>(mut self, dir: File, guest_path: P) -> Self { + self.preopens.push((guest_path.as_ref().to_owned(), dir)); + self + } + + /// Build a `WasiCtx`, consuming this `WasiCtxBuilder`. + /// + /// If any of the arguments or environment variables in this builder cannot be converted into + /// `CString`s, either due to NUL bytes or Unicode conversions, this returns `Error::EILSEQ`. + pub fn build(self) -> Result<WasiCtx> { + // Process arguments and environment variables into `CString`s, failing quickly if they + // contain any NUL bytes, or if conversion from `OsString` fails. + let args = self + .args + .into_iter() + .map(|arg| arg.into_utf8_cstring()) + .collect::<Result<Vec<CString>>>()?; + + let env = self + .env + .into_iter() + .map(|(k, v)| { + k.into_string().and_then(|mut pair| { + v.into_string().and_then(|v| { + pair.push('='); + pair.push_str(v.as_str()); + // We have valid UTF-8, but the keys and values have not yet been checked + // for NULs, so we do a final check here. + CString::new(pair).map_err(|_| Error::EILSEQ) + }) + }) + }) + .collect::<Result<Vec<CString>>>()?; + + let mut fds: HashMap<wasi::__wasi_fd_t, FdEntry> = HashMap::new(); + // Populate the non-preopen fds. + for (fd, pending) in self.fds { + log::debug!("WasiCtx inserting ({:?}, {:?})", fd, pending); + match pending { + PendingFdEntry::Thunk(f) => { + fds.insert(fd, f()?); + } + PendingFdEntry::File(f) => { + fds.insert(fd, FdEntry::from(f)?); + } + } + } + // Then add the preopen fds. Startup code in the guest starts looking at fd 3 for preopens, + // so we start from there. This variable is initially 2, though, because the loop + // immediately does the increment and check for overflow. + let mut preopen_fd: wasi::__wasi_fd_t = 2; + for (guest_path, dir) in self.preopens { + // We do the increment at the beginning of the loop body, so that we don't overflow + // unnecessarily if we have exactly the maximum number of file descriptors. + preopen_fd = preopen_fd.checked_add(1).ok_or(Error::ENFILE)?; + + if !dir.metadata()?.is_dir() { + return Err(Error::EBADF); + } + + // We don't currently allow setting file descriptors other than 0-2, but this will avoid + // collisions if we restore that functionality in the future. + while fds.contains_key(&preopen_fd) { + preopen_fd = preopen_fd.checked_add(1).ok_or(Error::ENFILE)?; + } + let mut fe = FdEntry::from(dir)?; + fe.preopen_path = Some(guest_path); + log::debug!("WasiCtx inserting ({:?}, {:?})", preopen_fd, fe); + fds.insert(preopen_fd, fe); + log::debug!("WasiCtx fds = {:?}", fds); + } + + Ok(WasiCtx { args, env, fds }) + } +} + +#[derive(Debug)] +pub struct WasiCtx { + fds: HashMap<wasi::__wasi_fd_t, FdEntry>, + pub(crate) args: Vec<CString>, + pub(crate) env: Vec<CString>, +} + +impl WasiCtx { + /// Make a new `WasiCtx` with some default settings. + /// + /// - File descriptors 0, 1, and 2 inherit stdin, stdout, and stderr from the host process. + /// + /// - Environment variables are inherited from the host process. + /// + /// To override these behaviors, use `WasiCtxBuilder`. + pub fn new<S: AsRef<[u8]>>(args: impl IntoIterator<Item = S>) -> Result<Self> { + WasiCtxBuilder::new() + .args(args) + .inherit_stdio() + .inherit_env() + .build() + } + + /// Check if `WasiCtx` contains the specified raw WASI `fd`. + pub(crate) unsafe fn contains_fd_entry(&self, fd: wasi::__wasi_fd_t) -> bool { + self.fds.contains_key(&fd) + } + + /// Get an immutable `FdEntry` corresponding to the specified raw WASI `fd`. + pub(crate) unsafe fn get_fd_entry(&self, fd: wasi::__wasi_fd_t) -> Result<&FdEntry> { + self.fds.get(&fd).ok_or(Error::EBADF) + } + + /// Get a mutable `FdEntry` corresponding to the specified raw WASI `fd`. + pub(crate) unsafe fn get_fd_entry_mut( + &mut self, + fd: wasi::__wasi_fd_t, + ) -> Result<&mut FdEntry> { + self.fds.get_mut(&fd).ok_or(Error::EBADF) + } + + /// Insert the specified `FdEntry` into the `WasiCtx` object. + /// + /// The `FdEntry` will automatically get another free raw WASI `fd` assigned. Note that + /// the two subsequent free raw WASI `fd`s do not have to be stored contiguously. + pub(crate) fn insert_fd_entry(&mut self, fe: FdEntry) -> Result<wasi::__wasi_fd_t> { + // Never insert where stdio handles are expected to be. + let mut fd = 3; + while self.fds.contains_key(&fd) { + if let Some(next_fd) = fd.checked_add(1) { + fd = next_fd; + } else { + return Err(Error::EMFILE); + } + } + self.fds.insert(fd, fe); + Ok(fd) + } + + /// Insert the specified `FdEntry` with the specified raw WASI `fd` key into the `WasiCtx` + /// object. + pub(crate) fn insert_fd_entry_at( + &mut self, + fd: wasi::__wasi_fd_t, + fe: FdEntry, + ) -> Option<FdEntry> { + self.fds.insert(fd, fe) + } + + /// Remove `FdEntry` corresponding to the specified raw WASI `fd` from the `WasiCtx` object. + pub(crate) fn remove_fd_entry(&mut self, fd: wasi::__wasi_fd_t) -> Result<FdEntry> { + self.fds.remove(&fd).ok_or(Error::EBADF) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +
+// Due to https://github.com/rust-lang/rust/issues/64247 +#![allow(clippy::use_self)] +use crate::wasi; +use std::convert::Infallible; +use std::num::TryFromIntError; +use std::{ffi, str}; +use thiserror::Error; + +#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)] +#[repr(u16)] +#[error("{:?} ({})", self, wasi::strerror(*self as wasi::__wasi_errno_t))] +pub enum WasiError { + ESUCCESS = wasi::__WASI_ERRNO_SUCCESS, + E2BIG = wasi::__WASI_ERRNO_2BIG, + EACCES = wasi::__WASI_ERRNO_ACCES, + EADDRINUSE = wasi::__WASI_ERRNO_ADDRINUSE, + EADDRNOTAVAIL = wasi::__WASI_ERRNO_ADDRNOTAVAIL, + EAFNOSUPPORT = wasi::__WASI_ERRNO_AFNOSUPPORT, + EAGAIN = wasi::__WASI_ERRNO_AGAIN, + EALREADY = wasi::__WASI_ERRNO_ALREADY, + EBADF = wasi::__WASI_ERRNO_BADF, + EBADMSG = wasi::__WASI_ERRNO_BADMSG, + EBUSY = wasi::__WASI_ERRNO_BUSY, + ECANCELED = wasi::__WASI_ERRNO_CANCELED, + ECHILD = wasi::__WASI_ERRNO_CHILD, + ECONNABORTED = wasi::__WASI_ERRNO_CONNABORTED, + ECONNREFUSED = wasi::__WASI_ERRNO_CONNREFUSED, + ECONNRESET = wasi::__WASI_ERRNO_CONNRESET, + EDEADLK = wasi::__WASI_ERRNO_DEADLK, + EDESTADDRREQ = wasi::__WASI_ERRNO_DESTADDRREQ, + EDOM = wasi::__WASI_ERRNO_DOM, + EDQUOT = wasi::__WASI_ERRNO_DQUOT, + EEXIST = wasi::__WASI_ERRNO_EXIST, + EFAULT = wasi::__WASI_ERRNO_FAULT, + EFBIG = wasi::__WASI_ERRNO_FBIG, + EHOSTUNREACH = wasi::__WASI_ERRNO_HOSTUNREACH, + EIDRM = wasi::__WASI_ERRNO_IDRM, + EILSEQ = wasi::__WASI_ERRNO_ILSEQ, + EINPROGRESS = wasi::__WASI_ERRNO_INPROGRESS, + EINTR = wasi::__WASI_ERRNO_INTR, + EINVAL = wasi::__WASI_ERRNO_INVAL, + EIO = wasi::__WASI_ERRNO_IO, + EISCONN = wasi::__WASI_ERRNO_ISCONN, + EISDIR = wasi::__WASI_ERRNO_ISDIR, + ELOOP = wasi::__WASI_ERRNO_LOOP, + EMFILE = wasi::__WASI_ERRNO_MFILE, + EMLINK = wasi::__WASI_ERRNO_MLINK, + EMSGSIZE = wasi::__WASI_ERRNO_MSGSIZE, + EMULTIHOP = wasi::__WASI_ERRNO_MULTIHOP, + ENAMETOOLONG = wasi::__WASI_ERRNO_NAMETOOLONG, + ENETDOWN = wasi::__WASI_ERRNO_NETDOWN, + ENETRESET = wasi::__WASI_ERRNO_NETRESET, + ENETUNREACH = wasi::__WASI_ERRNO_NETUNREACH, + ENFILE = wasi::__WASI_ERRNO_NFILE, + ENOBUFS = wasi::__WASI_ERRNO_NOBUFS, + ENODEV = wasi::__WASI_ERRNO_NODEV, + ENOENT = wasi::__WASI_ERRNO_NOENT, + ENOEXEC = wasi::__WASI_ERRNO_NOEXEC, + ENOLCK = wasi::__WASI_ERRNO_NOLCK, + ENOLINK = wasi::__WASI_ERRNO_NOLINK, + ENOMEM = wasi::__WASI_ERRNO_NOMEM, + ENOMSG = wasi::__WASI_ERRNO_NOMSG, + ENOPROTOOPT = wasi::__WASI_ERRNO_NOPROTOOPT, + ENOSPC = wasi::__WASI_ERRNO_NOSPC, + ENOSYS = wasi::__WASI_ERRNO_NOSYS, + ENOTCONN = wasi::__WASI_ERRNO_NOTCONN, + ENOTDIR = wasi::__WASI_ERRNO_NOTDIR, + ENOTEMPTY = wasi::__WASI_ERRNO_NOTEMPTY, + ENOTRECOVERABLE = wasi::__WASI_ERRNO_NOTRECOVERABLE, + ENOTSOCK = wasi::__WASI_ERRNO_NOTSOCK, + ENOTSUP = wasi::__WASI_ERRNO_NOTSUP, + ENOTTY = wasi::__WASI_ERRNO_NOTTY, + ENXIO = wasi::__WASI_ERRNO_NXIO, + EOVERFLOW = wasi::__WASI_ERRNO_OVERFLOW, + EOWNERDEAD = wasi::__WASI_ERRNO_OWNERDEAD, + EPERM = wasi::__WASI_ERRNO_PERM, + EPIPE = wasi::__WASI_ERRNO_PIPE, + EPROTO = wasi::__WASI_ERRNO_PROTO, + EPROTONOSUPPORT = wasi::__WASI_ERRNO_PROTONOSUPPORT, + EPROTOTYPE = wasi::__WASI_ERRNO_PROTOTYPE, + ERANGE = wasi::__WASI_ERRNO_RANGE, + EROFS = wasi::__WASI_ERRNO_ROFS, + ESPIPE = wasi::__WASI_ERRNO_SPIPE, + ESRCH = wasi::__WASI_ERRNO_SRCH, + ESTALE = wasi::__WASI_ERRNO_STALE, + ETIMEDOUT = wasi::__WASI_ERRNO_TIMEDOUT, + ETXTBSY = wasi::__WASI_ERRNO_TXTBSY, + EXDEV = wasi::__WASI_ERRNO_XDEV, + ENOTCAPABLE = wasi::__WASI_ERRNO_NOTCAPABLE, +} + +impl WasiError { + pub fn as_raw_errno(self) -> wasi::__wasi_errno_t { + self as wasi::__wasi_errno_t + } +} + +#[derive(Debug, Error)] +pub enum Error { + #[error("WASI error code: {0}")] + Wasi(#[from] WasiError), + #[error("IO error: {0}")] + Io(#[from] std::io::Error), + #[cfg(unix)] + #[error("Yanix error: {0}")] + Yanix(#[from] yanix::YanixError), +} + +impl From<TryFromIntError> for Error { + fn from(_: TryFromIntError) -> Self { + Self::EOVERFLOW + } +} + +impl From<Infallible> for Error { + fn from(_: Infallible) -> Self { + unreachable!() + } +} + +impl From<str::Utf8Error> for Error { + fn from(_: str::Utf8Error) -> Self { + Self::EILSEQ + } +} + +impl From<ffi::NulError> for Error { + fn from(_: ffi::NulError) -> Self { + Self::EILSEQ + } +} + +impl From<&ffi::NulError> for Error { + fn from(_: &ffi::NulError) -> Self { + Self::EILSEQ + } +} + +impl Error { + pub(crate) fn as_wasi_error(&self) -> WasiError { + match self { + Self::Wasi(err) => *err, + Self::Io(err) => { + let err = match err.raw_os_error() { + Some(code) => Self::from_raw_os_error(code), + None => { + log::debug!("Inconvertible OS error: {}", err); + Self::EIO + } + }; + err.as_wasi_error() + } + #[cfg(unix)] + Self::Yanix(err) => { + use yanix::YanixError::*; + let err: Self = match err { + Errno(errno) => (*errno).into(), + NulError(err) => err.into(), + TryFromIntError(err) => (*err).into(), + }; + err.as_wasi_error() + } + } + } + + pub const ESUCCESS: Self = Error::Wasi(WasiError::ESUCCESS); + pub const E2BIG: Self = Error::Wasi(WasiError::E2BIG); + pub const EACCES: Self = Error::Wasi(WasiError::EACCES); + pub const EADDRINUSE: Self = Error::Wasi(WasiError::EADDRINUSE); + pub const EADDRNOTAVAIL: Self = Error::Wasi(WasiError::EADDRNOTAVAIL); + pub const EAFNOSUPPORT: Self = Error::Wasi(WasiError::EAFNOSUPPORT); + pub const EAGAIN: Self = Error::Wasi(WasiError::EAGAIN); + pub const EALREADY: Self = Error::Wasi(WasiError::EALREADY); + pub const EBADF: Self = Error::Wasi(WasiError::EBADF); + pub const EBADMSG: Self = Error::Wasi(WasiError::EBADMSG); + pub const EBUSY: Self = Error::Wasi(WasiError::EBUSY); + pub const ECANCELED: Self = Error::Wasi(WasiError::ECANCELED); + pub const ECHILD: Self = Error::Wasi(WasiError::ECHILD); + pub const ECONNABORTED: Self = Error::Wasi(WasiError::ECONNABORTED); + pub const ECONNREFUSED: Self = Error::Wasi(WasiError::ECONNREFUSED); + pub const ECONNRESET: Self = Error::Wasi(WasiError::ECONNRESET); + pub const EDEADLK: Self = Error::Wasi(WasiError::EDEADLK); + pub const EDESTADDRREQ: Self = Error::Wasi(WasiError::EDESTADDRREQ); + pub const EDOM: Self = Error::Wasi(WasiError::EDOM); + pub const EDQUOT: Self = Error::Wasi(WasiError::EDQUOT); + pub const EEXIST: Self = Error::Wasi(WasiError::EEXIST); + pub const EFAULT: Self = Error::Wasi(WasiError::EFAULT); + pub const EFBIG: Self = Error::Wasi(WasiError::EFBIG); + pub const EHOSTUNREACH: Self = Error::Wasi(WasiError::EHOSTUNREACH); + pub const EIDRM: Self = Error::Wasi(WasiError::EIDRM); + pub const EILSEQ: Self = Error::Wasi(WasiError::EILSEQ); + pub const EINPROGRESS: Self = Error::Wasi(WasiError::EINPROGRESS); + pub const EINTR: Self = Error::Wasi(WasiError::EINTR); + pub const EINVAL: Self = Error::Wasi(WasiError::EINVAL); + pub const EIO: Self = Error::Wasi(WasiError::EIO); + pub const EISCONN: Self = Error::Wasi(WasiError::EISCONN); + pub const EISDIR: Self = Error::Wasi(WasiError::EISDIR); + pub const ELOOP: Self = Error::Wasi(WasiError::ELOOP); + pub const EMFILE: Self = Error::Wasi(WasiError::EMFILE); + pub const EMLINK: Self = Error::Wasi(WasiError::EMLINK); + pub const EMSGSIZE: Self = Error::Wasi(WasiError::EMSGSIZE); + pub const EMULTIHOP: Self = Error::Wasi(WasiError::EMULTIHOP); + pub const ENAMETOOLONG: Self = Error::Wasi(WasiError::ENAMETOOLONG); + pub const ENETDOWN: Self = Error::Wasi(WasiError::ENETDOWN); + pub const ENETRESET: Self = Error::Wasi(WasiError::ENETRESET); + pub const ENETUNREACH: Self = Error::Wasi(WasiError::ENETUNREACH); + pub const ENFILE: Self = Error::Wasi(WasiError::ENFILE); + pub const ENOBUFS: Self = Error::Wasi(WasiError::ENOBUFS); + pub const ENODEV: Self = Error::Wasi(WasiError::ENODEV); + pub const ENOENT: Self = Error::Wasi(WasiError::ENOENT); + pub const ENOEXEC: Self = Error::Wasi(WasiError::ENOEXEC); + pub const ENOLCK: Self = Error::Wasi(WasiError::ENOLCK); + pub const ENOLINK: Self = Error::Wasi(WasiError::ENOLINK); + pub const ENOMEM: Self = Error::Wasi(WasiError::ENOMEM); + pub const ENOMSG: Self = Error::Wasi(WasiError::ENOMSG); + pub const ENOPROTOOPT: Self = Error::Wasi(WasiError::ENOPROTOOPT); + pub const ENOSPC: Self = Error::Wasi(WasiError::ENOSPC); + pub const ENOSYS: Self = Error::Wasi(WasiError::ENOSYS); + pub const ENOTCONN: Self = Error::Wasi(WasiError::ENOTCONN); + pub const ENOTDIR: Self = Error::Wasi(WasiError::ENOTDIR); + pub const ENOTEMPTY: Self = Error::Wasi(WasiError::ENOTEMPTY); + pub const ENOTRECOVERABLE: Self = Error::Wasi(WasiError::ENOTRECOVERABLE); + pub const ENOTSOCK: Self = Error::Wasi(WasiError::ENOTSOCK); + pub const ENOTSUP: Self = Error::Wasi(WasiError::ENOTSUP); + pub const ENOTTY: Self = Error::Wasi(WasiError::ENOTTY); + pub const ENXIO: Self = Error::Wasi(WasiError::ENXIO); + pub const EOVERFLOW: Self = Error::Wasi(WasiError::EOVERFLOW); + pub const EOWNERDEAD: Self = Error::Wasi(WasiError::EOWNERDEAD); + pub const EPERM: Self = Error::Wasi(WasiError::EPERM); + pub const EPIPE: Self = Error::Wasi(WasiError::EPIPE); + pub const EPROTO: Self = Error::Wasi(WasiError::EPROTO); + pub const EPROTONOSUPPORT: Self = Error::Wasi(WasiError::EPROTONOSUPPORT); + pub const EPROTOTYPE: Self = Error::Wasi(WasiError::EPROTOTYPE); + pub const ERANGE: Self = Error::Wasi(WasiError::ERANGE); + pub const EROFS: Self = Error::Wasi(WasiError::EROFS); + pub const ESPIPE: Self = Error::Wasi(WasiError::ESPIPE); + pub const ESRCH: Self = Error::Wasi(WasiError::ESRCH); + pub const ESTALE: Self = Error::Wasi(WasiError::ESTALE); + pub const ETIMEDOUT: Self = Error::Wasi(WasiError::ETIMEDOUT); + pub const ETXTBSY: Self = Error::Wasi(WasiError::ETXTBSY); + pub const EXDEV: Self = Error::Wasi(WasiError::EXDEV); + pub const ENOTCAPABLE: Self = Error::Wasi(WasiError::ENOTCAPABLE); +} + +pub(crate) trait FromRawOsError { + fn from_raw_os_error(code: i32) -> Self; +} + +pub(crate) type Result<T> = std::result::Result<T, Error>; + +pub(crate) trait AsWasiError { + fn as_wasi_error(&self) -> WasiError; +} + +impl<T> AsWasiError for Result<T> { + fn as_wasi_error(&self) -> WasiError { + self.as_ref() + .err() + .unwrap_or(&Error::ESUCCESS) + .as_wasi_error() + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +
+use crate::sys::dev_null; +use crate::sys::fdentry_impl::{ + descriptor_as_oshandle, determine_type_and_access_rights, OsHandle, +}; +use crate::{wasi, Error, Result}; +use std::marker::PhantomData; +use std::mem::ManuallyDrop; +use std::ops::{Deref, DerefMut}; +use std::path::PathBuf; +use std::{fs, io}; + +#[derive(Debug)] +pub(crate) enum Descriptor { + OsHandle(OsHandle), + Stdin, + Stdout, + Stderr, +} + +impl Descriptor { + /// Return a reference to the `OsHandle` treating it as an actual file/dir, and + /// allowing operations which require an actual file and not just a stream or + /// socket file descriptor. + pub(crate) fn as_file(&self) -> Result<&OsHandle> { + match self { + Self::OsHandle(file) => Ok(file), + _ => Err(Error::EBADF), + } + } + + /// Like `as_file`, but return a mutable reference. + pub(crate) fn as_file_mut(&mut self) -> Result<&mut OsHandle> { + match self { + Self::OsHandle(file) => Ok(file), + _ => Err(Error::EBADF), + } + } + + /// Return an `OsHandle`, which may be a stream or socket file descriptor. + pub(crate) fn as_os_handle<'descriptor>(&'descriptor self) -> OsHandleRef<'descriptor> { + descriptor_as_oshandle(self) + } +} + +/// An abstraction struct serving as a wrapper for a host `Descriptor` object which requires +/// certain base rights `rights_base` and inheriting rights `rights_inheriting` in order to be +/// accessed correctly. +/// +/// Here, the `descriptor` field stores the host `Descriptor` object (such as a file descriptor, or +/// stdin handle), and accessing it can only be done via the provided `FdEntry::as_descriptor` and +/// `FdEntry::as_descriptor_mut` methods which require a set of base and inheriting rights to be +/// specified, verifying whether the stored `Descriptor` object is valid for the rights specified. +#[derive(Debug)] +pub(crate) struct FdEntry { + pub(crate) file_type: wasi::__wasi_filetype_t, + descriptor: Descriptor, + pub(crate) rights_base: wasi::__wasi_rights_t, + pub(crate) rights_inheriting: wasi::__wasi_rights_t, + pub(crate) preopen_path: Option<PathBuf>, + // TODO: directories +} + +impl FdEntry { + pub(crate) fn from(file: fs::File) -> Result<Self> { + unsafe { determine_type_and_access_rights(&file) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::OsHandle(OsHandle::from(file)), + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stdin() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stdin()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stdin, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stdout() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stdout()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stdout, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stderr() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stderr()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stderr, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn null() -> Result<Self> { + Self::from(dev_null()?) + } + + /// Convert this `FdEntry` into a host `Descriptor` object provided the specified + /// `rights_base` and `rights_inheriting` rights are set on this `FdEntry` object. + /// + /// The `FdEntry` can only be converted into a valid `Descriptor` object if + /// the specified set of base rights `rights_base`, and inheriting rights `rights_inheriting` + /// is a subset of rights attached to this `FdEntry`. The check is performed using + /// `FdEntry::validate_rights` method. If the check fails, `Error::ENOTCAPABLE` is returned. + pub(crate) fn as_descriptor( + &self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<&Descriptor> { + self.validate_rights(rights_base, rights_inheriting)?; + Ok(&self.descriptor) + } + + /// Convert this `FdEntry` into a mutable host `Descriptor` object provided the specified + /// `rights_base` and `rights_inheriting` rights are set on this `FdEntry` object. + /// + /// The `FdEntry` can only be converted into a valid `Descriptor` object if + /// the specified set of base rights `rights_base`, and inheriting rights `rights_inheriting` + /// is a subset of rights attached to this `FdEntry`. The check is performed using + /// `FdEntry::validate_rights` method. If the check fails, `Error::ENOTCAPABLE` is returned. + pub(crate) fn as_descriptor_mut( + &mut self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<&mut Descriptor> { + self.validate_rights(rights_base, rights_inheriting)?; + Ok(&mut self.descriptor) + } + + /// Check if this `FdEntry` object satisfies the specified base rights `rights_base`, and + /// inheriting rights `rights_inheriting`; i.e., if rights attached to this `FdEntry` object + /// are a superset. + /// + /// Upon unsuccessful check, `Error::ENOTCAPABLE` is returned. + fn validate_rights( + &self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<()> { + let missing_base = !self.rights_base & rights_base; + let missing_inheriting = !self.rights_inheriting & rights_inheriting; + if missing_base != 0 || missing_inheriting != 0 { + log::trace!( + " | validate_rights failed: required: \ + rights_base = {:#x}, rights_inheriting = {:#x}; \ + actual: rights_base = {:#x}, rights_inheriting = {:#x}; \ + missing_base = {:#x}, missing_inheriting = {:#x}", + rights_base, + rights_inheriting, + self.rights_base, + self.rights_inheriting, + missing_base, + missing_inheriting + ); + Err(Error::ENOTCAPABLE) + } else { + Ok(()) + } + } + + /// Test whether this descriptor is considered a tty within WASI. + /// Note that since WASI itself lacks an `isatty` syscall and relies + /// on a conservative approximation, we use the same approximation here. + pub(crate) fn isatty(&self) -> bool { + self.file_type == wasi::__WASI_FILETYPE_CHARACTER_DEVICE + && (self.rights_base & (wasi::__WASI_RIGHTS_FD_SEEK | wasi::__WASI_RIGHTS_FD_TELL)) == 0 + } +} + +/// This allows an `OsHandle` to be temporarily borrowed from a +/// `Descriptor`. The `Descriptor` continues to own the resource, +/// and `OsHandleRef`'s lifetime parameter ensures that it doesn't +/// outlive the `Descriptor`. +pub(crate) struct OsHandleRef<'descriptor> { + handle: ManuallyDrop<OsHandle>, + _ref: PhantomData<&'descriptor Descriptor>, +} + +impl<'descriptor> OsHandleRef<'descriptor> { + pub(crate) fn new(handle: ManuallyDrop<OsHandle>) -> Self { + OsHandleRef { + handle, + _ref: PhantomData, + } + } +} + +impl<'descriptor> Deref for OsHandleRef<'descriptor> { + type Target = fs::File; + + fn deref(&self) -> &Self::Target { + &self.handle + } +} + +impl<'descriptor> DerefMut for OsHandleRef<'descriptor> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.handle + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +
+use crate::fs::{File, OpenOptions, ReadDir}; +use crate::{host, hostcalls, wasi, WasiCtx}; +#[cfg(unix)] +use std::os::unix::ffi::OsStrExt; +use std::{io, path::Path}; + +/// A reference to an open directory on the filesystem. +/// +/// TODO: Implement `Dir`-using versions of `std::fs`'s free functions: +/// `copy`, `create_dir`, `create_dir_all`, `hard_link`, `metadata`, +/// `read_link`, `read_to_string`, `remove_dir`, `remove_dir_all`, +/// `remove_file`, `rename`, `set_permissions`, `symlink_metadata`, and +/// `write`. +/// +/// Unlike `std::fs`, this API has no `canonicalize`, because absolute paths +/// don't interoperate well with the capability-oriented security model. +pub struct Dir<'ctx> { + ctx: &'ctx mut WasiCtx, + fd: wasi::__wasi_fd_t, +} + +impl<'ctx> Dir<'ctx> { + /// Constructs a new instance of `Self` from the given raw WASI file descriptor. + pub unsafe fn from_raw_wasi_fd(ctx: &'ctx mut WasiCtx, fd: wasi::__wasi_fd_t) -> Self { + Self { ctx, fd } + } + + /// Attempts to open a file in read-only mode. + /// + /// This corresponds to [`std::fs::File::open`], but only accesses paths + /// relative to and within `self`. + /// + /// TODO: Not yet implemented. Refactor the hostcalls functions to split out the + /// encoding/decoding parts from the underlying functionality, so that we can call + /// into the underlying functionality directly. + /// + /// [`std::fs::File::open`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.open + pub fn open_file<P: AsRef<Path>>(&mut self, path: P) -> io::Result<File> { + let path = path.as_ref(); + let mut fd = 0; + + // TODO: Refactor the hostcalls functions to split out the encoding/decoding + // parts from the underlying functionality, so that we can call into the + // underlying functionality directly. + // + // TODO: Set the requested rights to be readonly. + // + // TODO: Handle paths for non-Unix platforms which don't have `as_bytes()` + // on `OsStrExt`. + unimplemented!("Dir::open_file"); + /* + wasi_errno_to_io_error(hostcalls::path_open( + self.ctx, + self.fd, + wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW, + path.as_os_str().as_bytes(), + path.as_os_str().len(), + 0, + !0, + !0, + 0, + &mut fd, + ))?; + */ + + let ctx = self.ctx; + Ok(unsafe { File::from_raw_wasi_fd(ctx, fd) }) + } + + /// Opens a file at `path` with the options specified by `self`. + /// + /// This corresponds to [`std::fs::OpenOptions::open`]. + /// + /// Instead of being a method on `OpenOptions`, this is a method on `Dir`, + /// and it only accesses functions relative to and within `self`. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::OpenOptions::open`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.open + pub fn open_file_with<P: AsRef<Path>>( + &mut self, + path: P, + options: &OpenOptions, + ) -> io::Result<File> { + unimplemented!("Dir::open_file_with"); + } + + /// Attempts to open a directory. + /// + /// TODO: Not yet implemented. See the comment in `open_file`. + pub fn open_dir<P: AsRef<Path>>(&mut self, path: P) -> io::Result<Self> { + let path = path.as_ref(); + let mut fd = 0; + + // TODO: See the comment in `open_file`. + unimplemented!("Dir::open_dir"); + /* + wasi_errno_to_io_error(hostcalls::path_open( + self.ctx, + self.fd, + wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW, + path.as_os_str().as_bytes(), + wasi::__WASI_OFLAGS_DIRECTORY, + !0, + !0, + 0, + &mut fd, + ))?; + */ + + let ctx = self.ctx; + Ok(unsafe { Dir::from_raw_wasi_fd(ctx, fd) }) + } + + /// Opens a file in write-only mode. + /// + /// This corresponds to [`std::fs::File::create`], but only accesses paths + /// relative to and within `self`. + /// + /// TODO: Not yet implemented. See the comment in `open_file`. + /// + /// [`std::fs::File::create`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.create + pub fn create_file<P: AsRef<Path>>(&mut self, path: P) -> io::Result<File> { + let path = path.as_ref(); + let mut fd = 0; + + // TODO: See the comments in `open_file`. + // + // TODO: Set the requested rights to be read+write. + unimplemented!("Dir::create_file"); + /* + wasi_errno_to_io_error(hostcalls::path_open( + self.ctx, + self.fd, + wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW, + path.as_os_str().as_bytes(), + path.as_os_str().len(), + wasi::__WASI_OFLAGS_CREAT | wasi::__WASI_OFLAGS_TRUNC, + !0, + !0, + 0, + &mut fd, + ))?; + */ + + let ctx = self.ctx; + Ok(unsafe { File::from_raw_wasi_fd(ctx, fd) }) + } + + /// Returns an iterator over the entries within a directory. + /// + /// This corresponds to [`std::fs::read_dir`], but reads the directory + /// represented by `self`. + /// + /// TODO: Not yet implemented. We may need to wait until we have the ability + /// to duplicate file descriptors before we can implement read safely. For + /// now, use `into_read` instead. + /// + /// [`std::fs::read_dir`]: https://doc.rust-lang.org/std/fs/fn.read_dir.html + pub fn read(&mut self) -> io::Result<ReadDir> { + unimplemented!("Dir::read") + } + + /// Consumes self and returns an iterator over the entries within a directory + /// in the manner of `read`. + pub fn into_read(self) -> ReadDir { + unsafe { ReadDir::from_raw_wasi_fd(self.fd) } + } + + /// Read the entire contents of a file into a bytes vector. + /// + /// This corresponds to [`std::fs::read`], but only accesses paths + /// relative to and within `self`. + /// + /// [`std::fs::read`]: https://doc.rust-lang.org/std/fs/fn.read.html + pub fn read_file<P: AsRef<Path>>(&mut self, path: P) -> io::Result<Vec<u8>> { + use io::Read; + let mut file = self.open_file(path)?; + let mut bytes = Vec::with_capacity(initial_buffer_size(&file)); + file.read_to_end(&mut bytes)?; + Ok(bytes) + } + + /// Returns an iterator over the entries within a directory. + /// + /// This corresponds to [`std::fs::read_dir`], but only accesses paths + /// relative to and within `self`. + /// + /// [`std::fs::read_dir`]: https://doc.rust-lang.org/std/fs/fn.read_dir.html + pub fn read_dir<P: AsRef<Path>>(&mut self, path: P) -> io::Result<ReadDir> { + self.open_dir(path)?.read() + } +} + +impl<'ctx> Drop for Dir<'ctx> { + fn drop(&mut self) { + // Note that errors are ignored when closing a file descriptor. The + // reason for this is that if an error occurs we don't actually know if + // the file descriptor was closed or not, and if we retried (for + // something like EINTR), we might close another valid file descriptor + // opened after we closed ours. + let _ = unsafe { hostcalls::fd_close(self.ctx, &mut [], self.fd) }; + } +} + +/// Indicates how large a buffer to pre-allocate before reading the entire file. +/// +/// Derived from the function of the same name in libstd. +fn initial_buffer_size(file: &File) -> usize { + // Allocate one extra byte so the buffer doesn't need to grow before the + // final `read` call at the end of the file. Don't worry about `usize` + // overflow because reading will fail regardless in that case. + file.metadata().map(|m| m.len() as usize + 1).unwrap_or(0) +} + +// TODO: impl Debug for Dir +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +
+use std::{io, path::Path}; + +/// A builder used to create directories in various manners. +/// +/// This corresponds to [`std::fs::DirBuilder`]. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::DirBuilder`]: https://doc.rust-lang.org/std/fs/struct.DirBuilder.html +pub struct DirBuilder {} + +impl DirBuilder { + /// Creates a new set of options with default mode/security settings for all platforms and also non-recursive. + /// + /// This corresponds to [`std::fs::DirBuilder::new`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirBuilder::new`]: https://doc.rust-lang.org/std/fs/struct.DirBuilder.html#method.new + pub fn new() -> Self { + unimplemented!("DirBuilder::new"); + } + + /// Indicates that directories should be created recursively, creating all parent directories. + /// + /// This corresponds to [`std::fs::DirBuilder::recursive`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirBuilder::recursive`]: https://doc.rust-lang.org/std/fs/struct.DirBuilder.html#method.recursive + pub fn recursive(&mut self, recursive: bool) -> &mut Self { + unimplemented!("DirBuilder::recursive"); + } + + /// Creates the specified directory with the options configured in this builder. + /// + /// This corresponds to [`std::fs::DirBuilder::create`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirBuilder::create`]: https://doc.rust-lang.org/std/fs/struct.DirBuilder.html#method.create + pub fn create<P: AsRef<Path>>(&self, path: P) -> io::Result<()> { + unimplemented!("DirBuilder::create"); + } +} + +// TODO: functions from DirBuilderExt? + +// TODO: impl Debug for DirBuilder +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +
+use crate::fs::{FileType, Metadata}; +use std::{ffi, io}; + +/// Entries returned by the ReadDir iterator. +/// +/// This corresponds to [`std::fs::DirEntry`]. +/// +/// Unlike `std::fs::DirEntry`, this API has no `DirEntry::path`, because +/// absolute paths don't interoperate well with the capability-oriented +/// security model. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::DirEntry`]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html +pub struct DirEntry {} + +impl DirEntry { + /// Returns the metadata for the file that this entry points at. + /// + /// This corresponds to [`std::fs::DirEntry::metadata`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirEntry::metadata`]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html#method.metadata + pub fn metadata(&self) -> io::Result<Metadata> { + unimplemented!("DirEntry::metadata"); + } + + /// Returns the file type for the file that this entry points at. + /// + /// This to [`std::fs::DirEntry::file_type`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirEntry::file_type`]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html#method.file_type + pub fn file_type(&self) -> io::Result<FileType> { + unimplemented!("DirEntry::file_type"); + } + + /// Returns the bare file name of this directory entry without any other leading path component. + /// + /// This corresponds to [`std::fs::DirEntry::file_name`], though it returns + /// `String` rather than `OsString`. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::DirEntry::file_name`]: https://doc.rust-lang.org/std/fs/struct.DirEntry.html#method.file_name + pub fn file_name(&self) -> String { + unimplemented!("DirEntry::file_name"); + } +} + +// TODO: impl Debug for DirEntry +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +
+use crate::fs::Metadata; +use crate::{host, hostcalls, hostcalls_impl, wasi, Result, WasiCtx}; +use std::io; + +/// A reference to an open file on the filesystem. +/// +/// This corresponds to [`std::fs::File`]. +/// +/// Note that this `File` has no `open` or `create` methods. To open or create +/// a file, you must first obtain a [`Dir`] containing the file, and then call +/// [`Dir::open_file`] or [`Dir::create_file`]. +/// +/// [`std::fs::File`]: https://doc.rust-lang.org/std/fs/struct.File.html +/// [`Dir`]: struct.Dir.html +/// [`Dir::open_file`]: struct.Dir.html#method.open_file +/// [`Dir::create_file`]: struct.Dir.html#method.create_file +pub struct File<'ctx> { + ctx: &'ctx mut WasiCtx, + fd: wasi::__wasi_fd_t, +} + +impl<'ctx> File<'ctx> { + /// Constructs a new instance of `Self` from the given raw WASI file descriptor. + /// + /// This corresponds to [`std::fs::File::from_raw_fd`]. + /// + /// [`std::fs::File::from_raw_fd`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.from_raw_fd + pub unsafe fn from_raw_wasi_fd(ctx: &'ctx mut WasiCtx, fd: wasi::__wasi_fd_t) -> Self { + Self { ctx, fd } + } + + /// Attempts to sync all OS-internal metadata to disk. + /// + /// This corresponds to [`std::fs::File::sync_all`]. + /// + /// [`std::fs::File::sync_all`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.sync_all + pub fn sync_all(&self) -> Result<()> { + unsafe { + hostcalls_impl::fd_sync(self.ctx, &mut [], self.fd)?; + } + Ok(()) + } + + /// This function is similar to `sync_all`, except that it may not synchronize + /// file metadata to the filesystem. + /// + /// This corresponds to [`std::fs::File::sync_data`]. + /// + /// [`std::fs::File::sync_data`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.sync_data + pub fn sync_data(&self) -> Result<()> { + unsafe { + hostcalls_impl::fd_datasync(self.ctx, &mut [], self.fd)?; + } + Ok(()) + } + + /// Truncates or extends the underlying file, updating the size of this file + /// to become size. + /// + /// This corresponds to [`std::fs::File::set_len`]. + /// + /// [`std::fs::File::set_len`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.set_len + pub fn set_len(&self, size: u64) -> Result<()> { + unsafe { + hostcalls_impl::fd_filestat_set_size(self.ctx, &mut [], self.fd, size)?; + } + Ok(()) + } + + /// Queries metadata about the underlying file. + /// + /// This corresponds to [`std::fs::File::metadata`]. + /// + /// [`std::fs::File::metadata`]: https://doc.rust-lang.org/std/fs/struct.File.html#method.metadata + pub fn metadata(&self) -> Result<Metadata> { + Ok(Metadata {}) + } +} + +impl<'ctx> Drop for File<'ctx> { + fn drop(&mut self) { + // Note that errors are ignored when closing a file descriptor. The + // reason for this is that if an error occurs we don't actually know if + // the file descriptor was closed or not, and if we retried (for + // something like EINTR), we might close another valid file descriptor + // opened after we closed ours. + let _ = unsafe { hostcalls::fd_close(self.ctx, &mut [], self.fd) }; + } +} + +impl<'ctx> io::Read for File<'ctx> { + /// TODO: Not yet implemented. See the comment in `Dir::open_file`. + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + let iov = [host::__wasi_iovec_t { + buf: buf.as_mut_ptr() as *mut u8, + buf_len: buf.len(), + }]; + let mut nread = 0; + + // TODO: See the comment in `Dir::open_file`. + unimplemented!("File::read"); + /* + wasi_errno_to_io_error(unsafe { + hostcalls::fd_read(self.ctx, self.fd, &iov, 1, &mut nread) + })?; + */ + + Ok(nread) + } +} + +// TODO: traits to implement: Write, Seek + +// TODO: functions from FileExt? + +// TODO: impl Debug for File +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +
+/// A structure representing a type of file with accessors for each file type. +/// It is returned by `Metadata::file_type` method. +/// +/// This corresponds to [`std::fs::FileType`]. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::FileType`]: https://doc.rust-lang.org/std/fs/struct.FileType.html +#[derive(Copy, Clone, Eq, PartialEq, Hash)] +pub struct FileType {} + +impl FileType { + /// Tests whether this file type represents a directory. + /// + /// This corresponds to [`std::fs::FileType::is_dir`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::FileType::is_dir`]: https://doc.rust-lang.org/std/fs/struct.FileType.html#method.is_dir + pub fn is_dir(&self) -> bool { + unimplemented!("FileType::is_dir"); + } + + /// Tests whether this file type represents a regular file. + /// + /// This corresponds to [`std::fs::FileType::is_file`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::FileType::is_file`]: https://doc.rust-lang.org/std/fs/struct.FileType.html#method.is_file + pub fn is_file(&self) -> bool { + unimplemented!("FileType::is_file"); + } + + /// Tests whether this file type represents a symbolic link. + /// + /// This corresponds to [`std::fs::FileType::is_symlink`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::FileType::is_symlink`]: https://doc.rust-lang.org/std/fs/struct.FileType.html#method.is_symlink + pub fn is_symlink(&self) -> bool { + unimplemented!("FileType::is_symlink"); + } +} + +// TODO: functions from FileTypeExt? + +// TODO: impl Debug for FileType +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +
+use crate::fs::{FileType, Permissions}; +use std::{io, time::SystemTime}; + +/// Metadata information about a file. +/// +/// This corresponds to [`std::fs::Metadata`]. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::Metadata`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html +#[derive(Clone)] +pub struct Metadata {} + +impl Metadata { + /// Returns the file type for this metadata. + /// + /// This corresponds to [`std::fs::Metadata::file_type`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::file_type`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.file_type + pub fn file_type(&self) -> FileType { + unimplemented!("Metadata::file_type"); + } + + /// Returns true if this metadata is for a directory. + /// + /// This corresponds to [`std::fs::Metadata::is_dir`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::is_dir`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.is_dir + pub fn is_dir(&self) -> bool { + unimplemented!("Metadata::is_dir"); + } + + /// Returns true if this metadata is for a regular file. + /// + /// This corresponds to [`std::fs::Metadata::is_file`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::is_file`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.is_file + pub fn is_file(&self) -> bool { + unimplemented!("Metadata::is_file"); + } + + /// Returns the size of the file, in bytes, this metadata is for. + /// + /// This corresponds to [`std::fs::Metadata::len`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::len`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.len + pub fn len(&self) -> u64 { + unimplemented!("Metadata::len"); + } + + /// Returns the permissions of the file this metadata is for. + /// + /// This corresponds to [`std::fs::Metadata::permissions`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::permissions`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.permissions + pub fn permissions(&self) -> Permissions { + unimplemented!("Metadata::permissions"); + } + + /// Returns the last modification time listed in this metadata. + /// + /// This corresponds to [`std::fs::Metadata::modified`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::modified`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.modified + pub fn modified(&self) -> io::Result<SystemTime> { + unimplemented!("Metadata::modified"); + } + + /// Returns the last access time of this metadata. + /// + /// This corresponds to [`std::fs::Metadata::accessed`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::accessed`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.accessed + pub fn accessed(&self) -> io::Result<SystemTime> { + unimplemented!("Metadata::accessed"); + } + + /// Returns the creation time listed in this metadata. + /// + /// This corresponds to [`std::fs::Metadata::created`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Metadata::created`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.created + pub fn created(&self) -> io::Result<SystemTime> { + unimplemented!("Metadata::created"); + } +} + +// TODO: Functions from MetadataExt? + +// TODO: impl Debug for Metadata +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +
+//! A very experimental module modeled providing a high-level and safe +//! filesystem interface, modeled after `std::fs`, implemented on top of +//! WASI functions. +//! +//! Most functions in this API are not yet implemented! +//! +//! This corresponds to [`std::fs`]. +//! +//! Instead of [`std::fs`'s free functions] which operate on paths, this +//! crate has methods on [`Dir`] which operate on paths which must be +//! relative to and within the directory. +//! +//! Since all functions which expose raw file descriptors are `unsafe`, +//! I/O handles in this API are unforgeable (unsafe code notwithstanding). +//! This combined with WASI's lack of absolute paths provides a natural +//! capability-oriented interface. +//! +//! [`std::fs`]: https://doc.rust-lang.org/std/fs/index.html +//! [`std::fs`'s free functions]: https://doc.rust-lang.org/std/fs/index.html#functions +//! [`DIR`]: struct.Dir.html + +// TODO: When more things are implemented, remove these. +#![allow( + unused_imports, + unreachable_code, + unused_variables, + unused_mut, + unused_unsafe, + dead_code +)] + +mod dir; +mod dir_builder; +mod dir_entry; +mod file; +mod file_type; +mod metadata; +mod open_options; +mod permissions; +mod readdir; + +pub use dir::*; +pub use dir_builder::*; +pub use dir_entry::*; +pub use file::*; +pub use file_type::*; +pub use metadata::*; +pub use open_options::*; +pub use permissions::*; +pub use readdir::*; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +
+/// Options and flags which can be used to configure how a file is opened. +/// +/// This corresponds to [`std::fs::OpenOptions`]. +/// +/// Note that this `OpenOptions` has no `open` method. To open a file with +/// an `OptionOptions`, you must first obtain a [`Dir`] containing the file, and +/// then call [`Dir::open_file_with`]. +/// +/// [`std::fs::OpenOptions`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html +/// [`Dir`]: struct.Dir.html +/// [`Dir::open_file_with`]: struct.Dir.html#method.open_file_with +pub struct OpenOptions { + pub(crate) read: bool, + pub(crate) write: bool, + pub(crate) append: bool, + pub(crate) truncate: bool, + pub(crate) create: bool, + pub(crate) create_new: bool, +} + +impl OpenOptions { + /// Creates a blank new set of options ready for configuration. + /// + /// This corresponds to [`std::fs::OpenOptions::new`]. + /// + /// [`std::fs::OpenOptions::new`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.new + pub fn new() -> Self { + Self { + read: false, + write: false, + append: false, + truncate: false, + create: false, + create_new: false, + } + } + + /// Sets the option for read access. + /// + /// This corresponds to [`std::fs::OpenOptions::read`]. + /// + /// [`std::fs::OpenOptions::read`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.read + pub fn read(&mut self, read: bool) -> &mut Self { + self.read = read; + self + } + + /// Sets the option for write access. + /// + /// This corresponds to [`std::fs::OpenOptions::write`]. + /// + /// [`std::fs::OpenOptions::write`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.write + pub fn write(&mut self, write: bool) -> &mut Self { + self.write = write; + self + } + + /// Sets the option for the append mode. + /// + /// This corresponds to [`std::fs::OpenOptions::append`]. + /// + /// [`std::fs::OpenOptions::append`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.append + pub fn append(&mut self, append: bool) -> &mut Self { + self.append = append; + self + } + + /// Sets the option for truncating a previous file. + /// + /// This corresponds to [`std::fs::OpenOptions::truncate`]. + /// + /// [`std::fs::OpenOptions::truncate`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.truncate + pub fn truncate(&mut self, truncate: bool) -> &mut Self { + self.truncate = truncate; + self + } + + /// Sets the option to create a new file. + /// + /// This corresponds to [`std::fs::OpenOptions::create`]. + /// + /// [`std::fs::OpenOptions::create`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.create + pub fn create(&mut self, create: bool) -> &mut Self { + self.create = create; + self + } + + /// Sets the option to always create a new file. + /// + /// This corresponds to [`std::fs::OpenOptions::create_new`]. + /// + /// [`std::fs::OpenOptions::create_new`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html#method.create_new + pub fn create_new(&mut self, create_new: bool) -> &mut Self { + self.create_new = create_new; + self + } +} + +// TODO: Functions from OpenOptionsExt? +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +
+/// Representation of the various permissions on a file. +/// +/// This corresponds to [`std::fs::Permissions`]. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::Permissions`]: https://doc.rust-lang.org/std/fs/struct.Permissions.html +#[derive(Eq, PartialEq, Clone)] +pub struct Permissions {} + +impl Permissions { + /// Returns true if these permissions describe a readonly (unwritable) file. + /// + /// This corresponds to [`std::fs::Permissions::readonly`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Permissions::readonly`]: https://doc.rust-lang.org/std/fs/struct.Permissions.html#method.readonly + pub fn readonly(&self) -> bool { + unimplemented!("Permissions::readonly"); + } + + /// Modifies the readonly flag for this set of permissions. + /// + /// This corresponds to [`std::fs::Permissions::set_readonly`]. + /// + /// TODO: Not yet implemented. + /// + /// [`std::fs::Permissions::set_readonly`]: https://doc.rust-lang.org/std/fs/struct.Permissions.html#method.set_readonly + pub fn set_readonly(&mut self, readonly: bool) { + unimplemented!("Permissions::set_readonly"); + } +} + +// TODO: functions from PermissionsExt? + +// TODO: impl Debug for Permissions +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +
+use crate::fs::DirEntry; +use crate::{hostcalls, wasi}; + +/// Iterator over the entries in a directory. +/// +/// This corresponds to [`std::fs::ReadDir`]. +/// +/// TODO: Not yet implemented. +/// +/// [`std::fs::ReadDir`]: https://doc.rust-lang.org/std/fs/struct.ReadDir.html +pub struct ReadDir { + fd: wasi::__wasi_fd_t, +} + +impl ReadDir { + /// Constructs a new instance of `Self` from the given raw WASI file descriptor. + pub unsafe fn from_raw_wasi_fd(fd: wasi::__wasi_fd_t) -> Self { + Self { fd } + } +} + +/// TODO: Not yet implemented. +impl Iterator for ReadDir { + type Item = DirEntry; + + /// TODO: Not yet implemented. + fn next(&mut self) -> Option<Self::Item> { + unimplemented!("ReadDir::next"); + } +} + +// TODO: impl Debug for ReadDir +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +
+use crate::{Error, Result}; +use std::str; + +/// Creates not-owned WASI path from byte slice. +/// +/// NB WASI spec requires bytes to be valid UTF-8. Otherwise, +/// `__WASI_ERRNO_ILSEQ` error is returned. +pub(crate) fn path_from_slice<'a>(s: &'a [u8]) -> Result<&'a str> { + str::from_utf8(s).map_err(|_| Error::EILSEQ) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +
+//! WASI host types. These are types that contain raw pointers and `usize` +//! values, and so are platform-specific. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] + +use crate::wasi::*; +use crate::{Error, Result}; +use std::{convert::TryInto, io, mem, slice}; +use wig::witx_host_types; + +witx_host_types!("snapshot" "wasi_snapshot_preview1"); + +pub(crate) unsafe fn ciovec_to_host(ciovec: &__wasi_ciovec_t) -> io::IoSlice { + let slice = slice::from_raw_parts(ciovec.buf as *const u8, ciovec.buf_len); + io::IoSlice::new(slice) +} + +pub(crate) unsafe fn iovec_to_host_mut(iovec: &mut __wasi_iovec_t) -> io::IoSliceMut { + let slice = slice::from_raw_parts_mut(iovec.buf as *mut u8, iovec.buf_len); + io::IoSliceMut::new(slice) +} + +#[allow(dead_code)] // trouble with sockets +#[derive(Clone, Copy, Debug)] +#[repr(u8)] +pub(crate) enum FileType { + Unknown = __WASI_FILETYPE_UNKNOWN, + BlockDevice = __WASI_FILETYPE_BLOCK_DEVICE, + CharacterDevice = __WASI_FILETYPE_CHARACTER_DEVICE, + Directory = __WASI_FILETYPE_DIRECTORY, + RegularFile = __WASI_FILETYPE_REGULAR_FILE, + SocketDgram = __WASI_FILETYPE_SOCKET_DGRAM, + SocketStream = __WASI_FILETYPE_SOCKET_STREAM, + Symlink = __WASI_FILETYPE_SYMBOLIC_LINK, +} + +impl FileType { + pub(crate) fn to_wasi(&self) -> __wasi_filetype_t { + *self as __wasi_filetype_t + } +} + +#[derive(Debug, Clone)] +pub(crate) struct Dirent { + pub name: String, + pub ftype: FileType, + pub ino: u64, + pub cookie: __wasi_dircookie_t, +} + +impl Dirent { + /// Serialize the directory entry to the format define by `__wasi_fd_readdir`, + /// so that the serialized entries can be concatenated by the implementation. + pub fn to_wasi_raw(&self) -> Result<Vec<u8>> { + let name = self.name.as_bytes(); + let namlen = name.len(); + let dirent_size = mem::size_of::<__wasi_dirent_t>(); + let offset = dirent_size.checked_add(namlen).ok_or(Error::EOVERFLOW)?; + + let mut raw = Vec::<u8>::with_capacity(offset); + raw.resize(offset, 0); + + let sys_dirent = raw.as_mut_ptr() as *mut __wasi_dirent_t; + unsafe { + sys_dirent.write_unaligned(__wasi_dirent_t { + d_namlen: namlen.try_into()?, + d_ino: self.ino, + d_next: self.cookie, + d_type: self.ftype.to_wasi(), + }); + } + + let sys_name = unsafe { sys_dirent.offset(1) as *mut u8 }; + let sys_name = unsafe { slice::from_raw_parts_mut(sys_name, namlen) }; + sys_name.copy_from_slice(&name); + + Ok(raw) + } +} + +#[cfg(test)] +mod test { + use super::*; + #[test] + fn bindgen_test_layout___wasi_prestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).pr_type as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(pr_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).u as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_dir_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_dir_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_dir_t>())).pr_name_len as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_dir_t), + "::", + stringify!(pr_name_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_u_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_u)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_u)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_u_t>())).dir as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_u_t), + "::", + stringify!(dir) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 + 100 + 101 + 102 + 103 + 104 + 105 + 106 + 107 + 108 + 109 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 120 + 121 + 122 + 123 + 124 + 125 + 126 + 127 + 128 + 129 + 130 + 131 + 132 + 133 + 134 + 135 + 136 + 137 + 138 + 139 + 140 + 141 + 142 + 143 + 144 + 145 + 146 + 147 + 148 + 149 + 150 + 151 + 152 + 153 + 154 + 155 + 156 + 157 + 158 + 159 + 160 + 161 + 162 + 163 + 164 + 165 + 166 + 167 + 168 + 169 + 170 + 171 + 172 + 173 + 174 + 175 + 176 + 177 + 178 + 179 + 180 + 181 + 182 + 183 + 184 + 185 + 186 + 187 + 188 + 189 + 190 + 191 + 192 + 193 + 194 + 195 + 196 + 197 + 198 + 199 + 200 + 201 + 202 + 203 + 204 + 205 + 206 + 207 + 208 + 209 + 210 + 211 + 212 + 213 + 214 + 215 + 216 + 217 + 218 + 219 + 220 + 221 + 222 + 223 + 224 + 225 + 226 + 227 + 228 + 229 + 230 + 231 + 232 + 233 + 234 + 235 + 236 + 237 + 238 + 239 + 240 + 241 + 242 + 243 + 244 + 245 + 246 + 247 + 248 + 249 + 250 + 251 + 252 + 253 + 254 + 255 + 256 + 257 + 258 + 259 + 260 + 261 + 262 + 263 + 264 + 265 + 266 + 267 + 268 + 269 + 270 + 271 + 272 + 273 + 274 + 275 + 276 + 277 + 278 + 279 + 280 + 281 + 282 + 283 + 284 + 285 + 286 + 287 + 288 + 289 + 290 + 291 + 292 + 293 + 294 + 295 + 296 + 297 + 298 + 299 + 300 + 301 + 302 + 303 + 304 + 305 + 306 + 307 + 308 + 309 + 310 + 311 + 312 + 313 + 314 + 315 + 316 + 317 + 318 + 319 + 320 + 321 + 322 + 323 + 324 + 325 + 326 + 327 + 328 + 329 + 330 + 331 + 332 + 333 + 334 + 335 + 336 + 337 + 338 + 339 + 340 + 341 + 342 + 343 + 344 + 345 + 346 + 347 + 348 + 349 + 350 + 351 + 352 + 353 + 354 + 355 + 356 + 357 + 358 + 359 + 360 + 361 + 362 + 363 + 364 + 365 + 366 + 367 + 368 + 369 + 370 + 371 + 372 + 373 + 374 + 375 + 376 + 377 + 378 + 379 + 380 + 381 + 382 + 383 + 384 + 385 + 386 + 387 + 388 + 389 + 390 + 391 + 392 + 393 + 394 + 395 + 396 + 397 + 398 + 399 + 400 + 401 + 402 + 403 + 404 + 405 + 406 + 407 + 408 + 409 + 410 + 411 + 412 + 413 + 414 + 415 + 416 + 417 + 418 + 419 + 420 + 421 + 422 + 423 + 424 + 425 + 426 + 427 + 428 + 429 + 430 + 431 + 432 + 433 + 434 + 435 + 436 + 437 + 438 + 439 + 440 + 441 + 442 + 443 + 444 + 445 + 446 + 447 + 448 + 449 + 450 + 451 + 452 + 453 + 454 + 455 + 456 + 457 + 458 + 459 + 460 + 461 + 462 + 463 + 464 + 465 + 466 + 467 + 468 + 469 + 470 + 471 + 472 + 473 + 474 + 475 + 476 + 477 + 478 + 479 + 480 + 481 + 482 + 483 + 484 + 485 + 486 + 487 + 488 + 489 + 490 + 491 + 492 + 493 + 494 + 495 + 496 + 497 + 498 + 499 + 500 + 501 + 502 + 503 + 504 + 505 + 506 + 507 + 508 + 509 + 510 + 511 + 512 + 513 + 514 + 515 + 516 + 517 + 518 + 519 + 520 + 521 + 522 + 523 + 524 + 525 + 526 + 527 + 528 + 529 + 530 + 531 + 532 + 533 + 534 + 535 + 536 + 537 + 538 + 539 + 540 + 541 + 542 + 543 + 544 + 545 + 546 + 547 + 548 + 549 + 550 + 551 + 552 + 553 + 554 + 555 + 556 + 557 + 558 + 559 + 560 + 561 + 562 + 563 + 564 + 565 + 566 + 567 + 568 + 569 + 570 + 571 + 572 + 573 + 574 + 575 + 576 + 577 + 578 + 579 + 580 + 581 + 582 + 583 + 584 + 585 + 586 + 587 + 588 + 589 + 590 + 591 + 592 + 593 + 594 + 595 + 596 + 597 + 598 + 599 + 600 + 601 + 602 + 603 + 604 + 605 + 606 + 607 + 608 + 609 + 610 + 611 + 612 + 613 + 614 + 615 + 616 + 617 + 618 + 619 + 620 + 621 + 622 + 623 + 624 + 625 + 626 + 627 + 628 + 629 + 630 + 631 + 632 + 633 + 634 + 635 + 636 + 637 + 638 + 639 + 640 + 641 + 642 + 643 + 644 + 645 + 646 + 647 + 648 + 649 + 650 + 651 + 652 + 653 + 654 + 655 + 656 + 657 + 658 + 659 + 660 + 661 + 662 + 663 + 664 + 665 + 666 + 667 + 668 + 669 + 670 + 671 + 672 + 673 + 674 + 675 + 676 + 677 + 678 + 679 + 680 + 681 + 682 + 683 + 684 + 685 + 686 + 687 + 688 + 689 + 690 + 691 + 692 + 693 + 694 + 695 + 696 + 697 + 698 + 699 + 700 + 701 + 702 + 703 + 704 + 705 + 706 + 707 + 708 + 709 + 710 + 711 + 712 + 713 + 714 + 715 + 716 + 717 + 718 + 719 + 720 + 721 + 722 + 723 + 724 + 725 + 726 + 727 + 728 + 729 + 730 + 731 + 732 + 733 + 734 + 735 + 736 + 737 + 738 + 739 + 740 + 741 + 742 + 743 + 744 + 745 + 746 + 747 + 748 + 749 + 750 + 751 + 752 + 753 + 754 + 755 + 756 + 757 + 758 + 759 + 760 + 761 + 762 + 763 + 764 + 765 + 766 + 767 + 768 + 769 + 770 + 771 + 772 + 773 + 774 + 775 + 776 + 777 + 778 + 779 + 780 + 781 + 782 + 783 + 784 + 785 + 786 + 787 + 788 + 789 + 790 + 791 + 792 + 793 + 794 + 795 + 796 + 797 + 798 + 799 + 800 + 801 + 802 + 803 + 804 + 805 + 806 + 807 + 808 + 809 + 810 + 811 + 812 + 813 + 814 + 815 + 816 + 817 + 818 + 819 + 820 + 821 + 822 + 823 + 824 + 825 + 826 + 827 + 828 + 829 + 830 + 831 + 832 + 833 + 834 + 835 + 836 + 837 + 838 + 839 + 840 + 841 + 842 + 843 + 844 + 845 + 846 + 847 + 848 + 849 + 850 + 851 + 852 + 853 + 854 + 855 + 856 + 857 + 858 + 859 + 860 + 861 + 862 + 863 + 864 + 865 + 866 + 867 + 868 + 869 + 870 + 871 + 872 + 873 + 874 + 875 + 876 + 877 + 878 + 879 + 880 + 881 + 882 + 883 + 884 + 885 + 886 + 887 + 888 + 889 + 890 + 891 + 892 + 893 + 894 + 895 + 896 + 897 + 898 + 899 + 900 + 901 + 902 + 903 + 904 + 905 + 906 + 907 + 908 + 909 + 910 + 911 + 912 + 913 + 914 + 915 + 916 + 917 + 918 + 919 + 920 + 921 + 922 + 923 + 924 + 925 + 926 + 927 + 928 + 929 + 930 + 931 + 932 + 933 + 934 + 935 + 936 + 937 + 938 + 939 + 940 + 941 + 942 + 943 + 944 + 945 + 946 + 947 + 948 + 949 + 950 + 951 + 952 + 953 + 954 + 955 + 956 + 957 + 958 + 959 + 960 + 961 + 962 + 963 + 964 + 965 + 966 + 967 + 968 + 969 + 970 + 971 + 972 + 973 + 974 + 975 + 976 + 977 + 978 + 979 + 980 + 981 + 982 + 983 + 984 + 985 + 986 + 987 + 988 + 989 + 990 + 991 + 992 + 993 + 994 + 995 + 996 + 997 + 998 + 999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +
+#![allow(non_camel_case_types)] +use super::fs_helpers::path_get; +use crate::ctx::WasiCtx; +use crate::fdentry::{Descriptor, FdEntry}; +use crate::helpers::*; +use crate::memory::*; +use crate::sandboxed_tty_writer::SandboxedTTYWriter; +use crate::sys::hostcalls_impl::fs_helpers::path_open_rights; +use crate::sys::{host_impl, hostcalls_impl}; +use crate::{helpers, host, wasi, wasi32, Error, Result}; +use filetime::{set_file_handle_times, FileTime}; +use log::trace; +use std::fs::File; +use std::io::{self, Read, Seek, SeekFrom, Write}; +use std::ops::DerefMut; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +pub(crate) unsafe fn fd_close( + wasi_ctx: &mut WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_close(fd={:?})", fd); + + if let Ok(fe) = wasi_ctx.get_fd_entry(fd) { + // can't close preopened files + if fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + } + + wasi_ctx.remove_fd_entry(fd)?; + Ok(()) +} + +pub(crate) unsafe fn fd_datasync( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_datasync(fd={:?})", fd); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_DATASYNC, 0)? + .as_file()?; + + fd.sync_data().map_err(Into::into) +} + +pub(crate) unsafe fn fd_pread( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + offset: wasi::__wasi_filesize_t, + nread: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_pread(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nread + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_READ | wasi::__WASI_RIGHTS_FD_SEEK, 0)? + .as_file()?; + + let iovs = dec_iovec_slice(memory, iovs_ptr, iovs_len)?; + + if offset > i64::max_value() as u64 { + return Err(Error::EIO); + } + let buf_size = iovs.iter().map(|v| v.buf_len).sum(); + let mut buf = vec![0; buf_size]; + let host_nread = hostcalls_impl::fd_pread(fd, &mut buf, offset)?; + let mut buf_offset = 0; + let mut left = host_nread; + for iov in &iovs { + if left == 0 { + break; + } + let vec_len = std::cmp::min(iov.buf_len, left); + std::slice::from_raw_parts_mut(iov.buf as *mut u8, vec_len) + .copy_from_slice(&buf[buf_offset..buf_offset + vec_len]); + buf_offset += vec_len; + left -= vec_len; + } + + trace!(" | *nread={:?}", host_nread); + + enc_usize_byref(memory, nread, host_nread) +} + +pub(crate) unsafe fn fd_pwrite( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + offset: wasi::__wasi_filesize_t, + nwritten: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_pwrite(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nwritten + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor( + wasi::__WASI_RIGHTS_FD_WRITE | wasi::__WASI_RIGHTS_FD_SEEK, + 0, + )? + .as_file()?; + let iovs = dec_ciovec_slice(memory, iovs_ptr, iovs_len)?; + + if offset > i64::max_value() as u64 { + return Err(Error::EIO); + } + let buf_size = iovs.iter().map(|v| v.buf_len).sum(); + let mut buf = Vec::with_capacity(buf_size); + for iov in &iovs { + buf.extend_from_slice(std::slice::from_raw_parts( + iov.buf as *const u8, + iov.buf_len, + )); + } + let host_nwritten = hostcalls_impl::fd_pwrite(fd, &buf, offset)?; + + trace!(" | *nwritten={:?}", host_nwritten); + + enc_usize_byref(memory, nwritten, host_nwritten) +} + +pub(crate) unsafe fn fd_read( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + nread: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_read(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + nread + ); + + let mut iovs = dec_iovec_slice(memory, iovs_ptr, iovs_len)?; + let mut iovs: Vec<io::IoSliceMut> = iovs + .iter_mut() + .map(|vec| host::iovec_to_host_mut(vec)) + .collect(); + + let maybe_host_nread = match wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_READ, 0)? + { + Descriptor::OsHandle(file) => file.read_vectored(&mut iovs), + Descriptor::Stdin => io::stdin().read_vectored(&mut iovs), + _ => return Err(Error::EBADF), + }; + + let host_nread = maybe_host_nread?; + + trace!(" | *nread={:?}", host_nread); + + enc_usize_byref(memory, nread, host_nread) +} + +pub(crate) unsafe fn fd_renumber( + wasi_ctx: &mut WasiCtx, + _memory: &mut [u8], + from: wasi::__wasi_fd_t, + to: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_renumber(from={:?}, to={:?})", from, to); + + if !wasi_ctx.contains_fd_entry(from) { + return Err(Error::EBADF); + } + + // Don't allow renumbering over a pre-opened resource. + // TODO: Eventually, we do want to permit this, once libpreopen in + // userspace is capable of removing entries from its tables as well. + let from_fe = wasi_ctx.get_fd_entry(from)?; + if from_fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + if let Ok(to_fe) = wasi_ctx.get_fd_entry(to) { + if to_fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + } + + let fe = wasi_ctx.remove_fd_entry(from)?; + wasi_ctx.insert_fd_entry_at(to, fe); + + Ok(()) +} + +pub(crate) unsafe fn fd_seek( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filedelta_t, + whence: wasi::__wasi_whence_t, + newoffset: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_seek(fd={:?}, offset={:?}, whence={}, newoffset={:#x?})", + fd, + offset, + wasi::whence_to_str(whence), + newoffset + ); + + let rights = if offset == 0 && whence == wasi::__WASI_WHENCE_CUR { + wasi::__WASI_RIGHTS_FD_TELL + } else { + wasi::__WASI_RIGHTS_FD_SEEK | wasi::__WASI_RIGHTS_FD_TELL + }; + let fd = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(rights, 0)? + .as_file_mut()?; + + let pos = match whence { + wasi::__WASI_WHENCE_CUR => SeekFrom::Current(offset), + wasi::__WASI_WHENCE_END => SeekFrom::End(offset), + wasi::__WASI_WHENCE_SET => SeekFrom::Start(offset as u64), + _ => return Err(Error::EINVAL), + }; + let host_newoffset = fd.seek(pos)?; + + trace!(" | *newoffset={:?}", host_newoffset); + + enc_filesize_byref(memory, newoffset, host_newoffset) +} + +pub(crate) unsafe fn fd_tell( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + newoffset: wasi32::uintptr_t, +) -> Result<()> { + trace!("fd_tell(fd={:?}, newoffset={:#x?})", fd, newoffset); + + let fd = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_TELL, 0)? + .as_file_mut()?; + + let host_offset = fd.seek(SeekFrom::Current(0))?; + + trace!(" | *newoffset={:?}", host_offset); + + enc_filesize_byref(memory, newoffset, host_offset) +} + +pub(crate) unsafe fn fd_fdstat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + fdstat_ptr: wasi32::uintptr_t, // *mut wasi::__wasi_fdstat_t +) -> Result<()> { + trace!("fd_fdstat_get(fd={:?}, fdstat_ptr={:#x?})", fd, fdstat_ptr); + + let mut fdstat = dec_fdstat_byref(memory, fdstat_ptr)?; + let host_fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(0, 0)? + .as_os_handle(); + + let fs_flags = hostcalls_impl::fd_fdstat_get(&host_fd)?; + + let fe = wasi_ctx.get_fd_entry(fd)?; + fdstat.fs_filetype = fe.file_type; + fdstat.fs_rights_base = fe.rights_base; + fdstat.fs_rights_inheriting = fe.rights_inheriting; + fdstat.fs_flags = fs_flags; + + trace!(" | *buf={:?}", fdstat); + + enc_fdstat_byref(memory, fdstat_ptr, fdstat) +} + +pub(crate) unsafe fn fd_fdstat_set_flags( + wasi_ctx: &mut WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + fdflags: wasi::__wasi_fdflags_t, +) -> Result<()> { + trace!("fd_fdstat_set_flags(fd={:?}, fdflags={:#x?})", fd, fdflags); + + let descriptor = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_FDSTAT_SET_FLAGS, 0)?; + + if let Some(new_handle) = + hostcalls_impl::fd_fdstat_set_flags(&descriptor.as_os_handle(), fdflags)? + { + *descriptor = Descriptor::OsHandle(new_handle); + } + + Ok(()) +} + +pub(crate) unsafe fn fd_fdstat_set_rights( + wasi_ctx: &mut WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + fs_rights_base: wasi::__wasi_rights_t, + fs_rights_inheriting: wasi::__wasi_rights_t, +) -> Result<()> { + trace!( + "fd_fdstat_set_rights(fd={:?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?})", + fd, + fs_rights_base, + fs_rights_inheriting + ); + + let fe = wasi_ctx.get_fd_entry_mut(fd)?; + if fe.rights_base & fs_rights_base != fs_rights_base + || fe.rights_inheriting & fs_rights_inheriting != fs_rights_inheriting + { + return Err(Error::ENOTCAPABLE); + } + fe.rights_base = fs_rights_base; + fe.rights_inheriting = fs_rights_inheriting; + + Ok(()) +} + +pub(crate) unsafe fn fd_sync( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_sync(fd={:?})", fd); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_SYNC, 0)? + .as_file()?; + fd.sync_all().map_err(Into::into) +} + +pub(crate) unsafe fn fd_write( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + nwritten: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_write(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + nwritten + ); + + let iovs = dec_ciovec_slice(memory, iovs_ptr, iovs_len)?; + let iovs: Vec<io::IoSlice> = iovs.iter().map(|vec| host::ciovec_to_host(vec)).collect(); + + // perform unbuffered writes + let entry = wasi_ctx.get_fd_entry_mut(fd)?; + let isatty = entry.isatty(); + let desc = entry.as_descriptor_mut(wasi::__WASI_RIGHTS_FD_WRITE, 0)?; + let host_nwritten = match desc { + Descriptor::OsHandle(file) => { + if isatty { + SandboxedTTYWriter::new(file.deref_mut()).write_vectored(&iovs)? + } else { + file.write_vectored(&iovs)? + } + } + Descriptor::Stdin => return Err(Error::EBADF), + Descriptor::Stdout => { + // lock for the duration of the scope + let stdout = io::stdout(); + let mut stdout = stdout.lock(); + let nwritten = if isatty { + SandboxedTTYWriter::new(&mut stdout).write_vectored(&iovs)? + } else { + stdout.write_vectored(&iovs)? + }; + stdout.flush()?; + nwritten + } + // Always sanitize stderr, even if it's not directly connected to a tty, + // because stderr is meant for diagnostics rather than binary output, + // and may be redirected to a file which could end up being displayed + // on a tty later. + Descriptor::Stderr => SandboxedTTYWriter::new(&mut io::stderr()).write_vectored(&iovs)?, + }; + + trace!(" | *nwritten={:?}", host_nwritten); + + enc_usize_byref(memory, nwritten, host_nwritten) +} + +pub(crate) unsafe fn fd_advise( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, + advice: wasi::__wasi_advice_t, +) -> Result<()> { + trace!( + "fd_advise(fd={:?}, offset={}, len={}, advice={:?})", + fd, + offset, + len, + advice + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_ADVISE, 0)? + .as_file()?; + + hostcalls_impl::fd_advise(fd, advice, offset, len) +} + +pub(crate) unsafe fn fd_allocate( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, +) -> Result<()> { + trace!("fd_allocate(fd={:?}, offset={}, len={})", fd, offset, len); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_ALLOCATE, 0)? + .as_file()?; + + let metadata = fd.metadata()?; + + let current_size = metadata.len(); + let wanted_size = offset.checked_add(len).ok_or(Error::E2BIG)?; + // This check will be unnecessary when rust-lang/rust#63326 is fixed + if wanted_size > i64::max_value() as u64 { + return Err(Error::E2BIG); + } + + if wanted_size > current_size { + fd.set_len(wanted_size).map_err(Into::into) + } else { + Ok(()) + } +} + +pub(crate) unsafe fn path_create_directory( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_create_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len, + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(helpers::path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let rights = wasi::__WASI_RIGHTS_PATH_OPEN | wasi::__WASI_RIGHTS_PATH_CREATE_DIRECTORY; + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, rights, 0, 0, path, false)?; + + hostcalls_impl::path_create_directory(resolved) +} + +pub(crate) unsafe fn path_link( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_dirfd: wasi::__wasi_fd_t, + old_flags: wasi::__wasi_lookupflags_t, + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + new_dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_link(old_dirfd={:?}, old_flags={:?}, old_path_ptr={:#x?}, old_path_len={}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_dirfd, + old_flags, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let old_fe = wasi_ctx.get_fd_entry(old_dirfd)?; + let new_fe = wasi_ctx.get_fd_entry(new_dirfd)?; + let resolved_old = path_get( + old_fe, + wasi::__WASI_RIGHTS_PATH_LINK_SOURCE, + 0, + 0, + old_path, + false, + )?; + let resolved_new = path_get( + new_fe, + wasi::__WASI_RIGHTS_PATH_LINK_TARGET, + 0, + 0, + new_path, + false, + )?; + + hostcalls_impl::path_link(resolved_old, resolved_new) +} + +pub(crate) unsafe fn path_open( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + oflags: wasi::__wasi_oflags_t, + fs_rights_base: wasi::__wasi_rights_t, + fs_rights_inheriting: wasi::__wasi_rights_t, + fs_flags: wasi::__wasi_fdflags_t, + fd_out_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_open(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={:?}, oflags={:#x?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?}, fs_flags={:#x?}, fd_out_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + oflags, + fs_rights_base, + fs_rights_inheriting, + fs_flags, + fd_out_ptr + ); + + // pre-encode fd_out_ptr to -1 in case of error in opening a path + enc_fd_byref(memory, fd_out_ptr, wasi::__wasi_fd_t::max_value())?; + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let (needed_base, needed_inheriting) = + path_open_rights(fs_rights_base, fs_rights_inheriting, oflags, fs_flags); + trace!( + " | needed_base = {}, needed_inheriting = {}", + needed_base, + needed_inheriting + ); + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + needed_base, + needed_inheriting, + dirflags, + path, + oflags & wasi::__WASI_OFLAGS_CREAT != 0, + )?; + + // which open mode do we need? + let read = fs_rights_base & (wasi::__WASI_RIGHTS_FD_READ | wasi::__WASI_RIGHTS_FD_READDIR) != 0; + let write = fs_rights_base + & (wasi::__WASI_RIGHTS_FD_DATASYNC + | wasi::__WASI_RIGHTS_FD_WRITE + | wasi::__WASI_RIGHTS_FD_ALLOCATE + | wasi::__WASI_RIGHTS_FD_FILESTAT_SET_SIZE) + != 0; + + trace!( + " | calling path_open impl: read={}, write={}", + read, + write + ); + let fd = hostcalls_impl::path_open(resolved, read, write, oflags, fs_flags)?; + + let mut fe = FdEntry::from(fd)?; + // We need to manually deny the rights which are not explicitly requested + // because FdEntry::from will assign maximal consistent rights. + fe.rights_base &= fs_rights_base; + fe.rights_inheriting &= fs_rights_inheriting; + let guest_fd = wasi_ctx.insert_fd_entry(fe)?; + + trace!(" | *fd={:?}", guest_fd); + + enc_fd_byref(memory, fd_out_ptr, guest_fd) +} + +pub(crate) unsafe fn path_readlink( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + buf_ptr: wasi32::uintptr_t, + buf_len: wasi32::size_t, + buf_used: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_readlink(dirfd={:?}, path_ptr={:#x?}, path_len={:?}, buf_ptr={:#x?}, buf_len={}, buf_used={:#x?})", + dirfd, + path_ptr, + path_len, + buf_ptr, + buf_len, + buf_used, + ); + + enc_usize_byref(memory, buf_used, 0)?; + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(helpers::path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", &path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, wasi::__WASI_RIGHTS_PATH_READLINK, 0, 0, &path, false)?; + + let mut buf = dec_slice_of_mut_u8(memory, buf_ptr, buf_len)?; + + let host_bufused = hostcalls_impl::path_readlink(resolved, &mut buf)?; + + trace!(" | (buf_ptr,*buf_used)={:?}", buf); + trace!(" | *buf_used={:?}", host_bufused); + + enc_usize_byref(memory, buf_used, host_bufused) +} + +pub(crate) unsafe fn path_rename( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_dirfd: wasi::__wasi_fd_t, + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + new_dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_rename(old_dirfd={:?}, old_path_ptr={:#x?}, old_path_len={:?}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={:?})", + old_dirfd, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let old_fe = wasi_ctx.get_fd_entry(old_dirfd)?; + let new_fe = wasi_ctx.get_fd_entry(new_dirfd)?; + let resolved_old = path_get( + old_fe, + wasi::__WASI_RIGHTS_PATH_RENAME_SOURCE, + 0, + 0, + old_path, + true, + )?; + let resolved_new = path_get( + new_fe, + wasi::__WASI_RIGHTS_PATH_RENAME_TARGET, + 0, + 0, + new_path, + true, + )?; + + log::debug!("path_rename resolved_old={:?}", resolved_old); + log::debug!("path_rename resolved_new={:?}", resolved_new); + + hostcalls_impl::path_rename(resolved_old, resolved_new) +} + +pub(crate) unsafe fn fd_filestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + filestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_filestat_get(fd={:?}, filestat_ptr={:#x?})", + fd, + filestat_ptr + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_FILESTAT_GET, 0)? + .as_file()?; + let host_filestat = hostcalls_impl::fd_filestat_get(fd)?; + + trace!(" | *filestat_ptr={:?}", host_filestat); + + enc_filestat_byref(memory, filestat_ptr, host_filestat) +} + +pub(crate) unsafe fn fd_filestat_set_times( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + trace!( + "fd_filestat_set_times(fd={:?}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + fd, + st_atim, + st_mtim, + fst_flags + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_FILESTAT_SET_TIMES, 0)? + .as_file()?; + + fd_filestat_set_times_impl(fd, st_atim, st_mtim, fst_flags) +} + +pub(crate) fn fd_filestat_set_times_impl( + fd: &File, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + let set_atim = fst_flags & wasi::__WASI_FSTFLAGS_ATIM != 0; + let set_atim_now = fst_flags & wasi::__WASI_FSTFLAGS_ATIM_NOW != 0; + let set_mtim = fst_flags & wasi::__WASI_FSTFLAGS_MTIM != 0; + let set_mtim_now = fst_flags & wasi::__WASI_FSTFLAGS_MTIM_NOW != 0; + + if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) { + return Err(Error::EINVAL); + } + let atim = if set_atim { + let time = UNIX_EPOCH + Duration::from_nanos(st_atim); + Some(FileTime::from_system_time(time)) + } else if set_atim_now { + let time = SystemTime::now(); + Some(FileTime::from_system_time(time)) + } else { + None + }; + + let mtim = if set_mtim { + let time = UNIX_EPOCH + Duration::from_nanos(st_mtim); + Some(FileTime::from_system_time(time)) + } else if set_mtim_now { + let time = SystemTime::now(); + Some(FileTime::from_system_time(time)) + } else { + None + }; + set_file_handle_times(fd, atim, mtim).map_err(Into::into) +} + +pub(crate) unsafe fn fd_filestat_set_size( + wasi_ctx: &WasiCtx, + _memory: &mut [u8], + fd: wasi::__wasi_fd_t, + st_size: wasi::__wasi_filesize_t, +) -> Result<()> { + trace!("fd_filestat_set_size(fd={:?}, st_size={})", fd, st_size); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_FILESTAT_SET_SIZE, 0)? + .as_file()?; + + // This check will be unnecessary when rust-lang/rust#63326 is fixed + if st_size > i64::max_value() as u64 { + return Err(Error::E2BIG); + } + fd.set_len(st_size).map_err(Into::into) +} + +pub(crate) unsafe fn path_filestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + filestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_filestat_get(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, filestat_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + filestat_ptr + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_FILESTAT_GET, + 0, + dirflags, + path, + false, + )?; + let host_filestat = hostcalls_impl::path_filestat_get(resolved, dirflags)?; + + trace!(" | *filestat_ptr={:?}", host_filestat); + + enc_filestat_byref(memory, filestat_ptr, host_filestat) +} + +pub(crate) unsafe fn path_filestat_set_times( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + trace!( + "path_filestat_set_times(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + st_atim, st_mtim, + fst_flags + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_FILESTAT_SET_TIMES, + 0, + dirflags, + path, + false, + )?; + + hostcalls_impl::path_filestat_set_times(resolved, dirflags, st_atim, st_mtim, fst_flags) +} + +pub(crate) unsafe fn path_symlink( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_symlink(old_path_ptr={:#x?}, old_path_len={}, dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_path_ptr, + old_path_len, + dirfd, + new_path_ptr, + new_path_len + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved_new = path_get(fe, wasi::__WASI_RIGHTS_PATH_SYMLINK, 0, 0, new_path, true)?; + + hostcalls_impl::path_symlink(old_path, resolved_new) +} + +pub(crate) unsafe fn path_unlink_file( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_unlink_file(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, wasi::__WASI_RIGHTS_PATH_UNLINK_FILE, 0, 0, path, false)?; + + hostcalls_impl::path_unlink_file(resolved) +} + +pub(crate) unsafe fn path_remove_directory( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_remove_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_REMOVE_DIRECTORY, + 0, + 0, + path, + true, + )?; + + log::debug!("path_remove_directory resolved={:?}", resolved); + + hostcalls_impl::path_remove_directory(resolved) +} + +pub(crate) unsafe fn fd_prestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + prestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_prestat_get(fd={:?}, prestat_ptr={:#x?})", + fd, + prestat_ptr + ); + + // TODO: should we validate any rights here? + let fe = wasi_ctx.get_fd_entry(fd)?; + let po_path = fe.preopen_path.as_ref().ok_or(Error::ENOTSUP)?; + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + return Err(Error::ENOTDIR); + } + + let path = host_impl::path_from_host(po_path.as_os_str())?; + + enc_prestat_byref( + memory, + prestat_ptr, + host::__wasi_prestat_t { + pr_type: wasi::__WASI_PREOPENTYPE_DIR, + u: host::__wasi_prestat_u_t { + dir: host::__wasi_prestat_dir_t { + pr_name_len: path.len(), + }, + }, + }, + ) +} + +pub(crate) unsafe fn fd_prestat_dir_name( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "fd_prestat_dir_name(fd={:?}, path_ptr={:#x?}, path_len={})", + fd, + path_ptr, + path_len + ); + + // TODO: should we validate any rights here? + let fe = wasi_ctx.get_fd_entry(fd)?; + let po_path = fe.preopen_path.as_ref().ok_or(Error::ENOTSUP)?; + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + return Err(Error::ENOTDIR); + } + + let path = host_impl::path_from_host(po_path.as_os_str())?; + + if path.len() > dec_usize(path_len) { + return Err(Error::ENAMETOOLONG); + } + + trace!(" | (path_ptr,path_len)='{}'", path); + + enc_slice_of_u8(memory, path.as_bytes(), path_ptr) +} + +pub(crate) unsafe fn fd_readdir( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + buf: wasi32::uintptr_t, + buf_len: wasi32::size_t, + cookie: wasi::__wasi_dircookie_t, + buf_used: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_readdir(fd={:?}, buf={:#x?}, buf_len={}, cookie={:#x?}, buf_used={:#x?})", + fd, + buf, + buf_len, + cookie, + buf_used, + ); + + enc_usize_byref(memory, buf_used, 0)?; + + let file = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_READDIR, 0)? + .as_file_mut()?; + let mut host_buf = dec_slice_of_mut_u8(memory, buf, buf_len)?; + + trace!(" | (buf,buf_len)={:?}", host_buf); + + let iter = hostcalls_impl::fd_readdir(file, cookie)?; + let mut host_bufused = 0; + for dirent in iter { + let dirent_raw = dirent?.to_wasi_raw()?; + let offset = dirent_raw.len(); + if host_buf.len() < offset { + break; + } else { + host_buf[0..offset].copy_from_slice(&dirent_raw); + host_bufused += offset; + host_buf = &mut host_buf[offset..]; + } + } + + trace!(" | *buf_used={:?}", host_bufused); + + enc_usize_byref(memory, buf_used, host_bufused) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +
+#![allow(non_camel_case_types)] +use crate::sys::host_impl; +use crate::sys::hostcalls_impl::fs_helpers::*; +use crate::{error::WasiError, fdentry::FdEntry, wasi, Error, Result}; +use std::fs::File; +use std::path::{Component, Path}; + +#[derive(Debug)] +pub(crate) struct PathGet { + dirfd: File, + path: String, +} + +impl PathGet { + pub(crate) fn dirfd(&self) -> &File { + &self.dirfd + } + + pub(crate) fn path(&self) -> &str { + &self.path + } +} + +/// Normalizes a path to ensure that the target path is located under the directory provided. +/// +/// This is a workaround for not having Capsicum support in the OS. +pub(crate) fn path_get( + fe: &FdEntry, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + dirflags: wasi::__wasi_lookupflags_t, + path: &str, + needs_final_component: bool, +) -> Result<PathGet> { + const MAX_SYMLINK_EXPANSIONS: usize = 128; + + if path.contains('\0') { + // if contains NUL, return EILSEQ + return Err(Error::EILSEQ); + } + + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + // if `dirfd` doesn't refer to a directory, return `ENOTDIR`. + return Err(Error::ENOTDIR); + } + + let dirfd = fe + .as_descriptor(rights_base, rights_inheriting)? + .as_file()? + .try_clone()?; + + // Stack of directory file descriptors. Index 0 always corresponds with the directory provided + // to this function. Entering a directory causes a file descriptor to be pushed, while handling + // ".." entries causes an entry to be popped. Index 0 cannot be popped, as this would imply + // escaping the base directory. + let mut dir_stack = vec![dirfd]; + + // Stack of paths left to process. This is initially the `path` argument to this function, but + // any symlinks we encounter are processed by pushing them on the stack. + let mut path_stack = vec![path.to_owned()]; + + // Track the number of symlinks we've expanded, so we can return `ELOOP` after too many. + let mut symlink_expansions = 0; + + // TODO: rewrite this using a custom posix path type, with a component iterator that respects + // trailing slashes. This version does way too much allocation, and is way too fiddly. + loop { + match path_stack.pop() { + Some(cur_path) => { + log::debug!("path_get cur_path = {:?}", cur_path); + + let ends_with_slash = cur_path.ends_with('/'); + let mut components = Path::new(&cur_path).components(); + let head = match components.next() { + None => return Err(Error::ENOENT), + Some(p) => p, + }; + let tail = components.as_path(); + + if tail.components().next().is_some() { + let mut tail = host_impl::path_from_host(tail.as_os_str())?; + if ends_with_slash { + tail.push('/'); + } + path_stack.push(tail); + } + + log::debug!("path_get path_stack = {:?}", path_stack); + + match head { + Component::Prefix(_) | Component::RootDir => { + // path is absolute! + return Err(Error::ENOTCAPABLE); + } + Component::CurDir => { + // "." so skip + } + Component::ParentDir => { + // ".." so pop a dir + let _ = dir_stack.pop().ok_or(Error::ENOTCAPABLE)?; + + // we're not allowed to pop past the original directory + if dir_stack.is_empty() { + return Err(Error::ENOTCAPABLE); + } + } + Component::Normal(head) => { + let mut head = host_impl::path_from_host(head)?; + if ends_with_slash { + // preserve trailing slash + head.push('/'); + } + + if !path_stack.is_empty() || (ends_with_slash && !needs_final_component) { + match openat(dir_stack.last().ok_or(Error::ENOTCAPABLE)?, &head) { + Ok(new_dir) => { + dir_stack.push(new_dir); + } + Err(e) => { + match e.as_wasi_error() { + WasiError::ELOOP + | WasiError::EMLINK + | WasiError::ENOTDIR => + // Check to see if it was a symlink. Linux indicates + // this with ENOTDIR because of the O_DIRECTORY flag. + { + // attempt symlink expansion + let mut link_path = readlinkat( + dir_stack.last().ok_or(Error::ENOTCAPABLE)?, + &head, + )?; + + symlink_expansions += 1; + if symlink_expansions > MAX_SYMLINK_EXPANSIONS { + return Err(Error::ELOOP); + } + + if head.ends_with('/') { + link_path.push('/'); + } + + log::debug!( + "attempted symlink expansion link_path={:?}", + link_path + ); + + path_stack.push(link_path); + } + _ => { + return Err(e); + } + } + } + } + + continue; + } else if ends_with_slash + || (dirflags & wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW) != 0 + { + // if there's a trailing slash, or if `LOOKUP_SYMLINK_FOLLOW` is set, attempt + // symlink expansion + match readlinkat(dir_stack.last().ok_or(Error::ENOTCAPABLE)?, &head) { + Ok(mut link_path) => { + symlink_expansions += 1; + if symlink_expansions > MAX_SYMLINK_EXPANSIONS { + return Err(Error::ELOOP); + } + + if head.ends_with('/') { + link_path.push('/'); + } + + log::debug!( + "attempted symlink expansion link_path={:?}", + link_path + ); + + path_stack.push(link_path); + continue; + } + Err(e) => { + if e.as_wasi_error() != WasiError::EINVAL + && e.as_wasi_error() != WasiError::ENOENT + // this handles the cases when trying to link to + // a destination that already exists, and the target + // path contains a slash + && e.as_wasi_error() != WasiError::ENOTDIR + { + return Err(e); + } + } + } + } + + // not a symlink, so we're done; + return Ok(PathGet { + dirfd: dir_stack.pop().ok_or(Error::ENOTCAPABLE)?, + path: head, + }); + } + } + } + None => { + // no further components to process. means we've hit a case like "." or "a/..", or if the + // input path has trailing slashes and `needs_final_component` is not set + return Ok(PathGet { + dirfd: dir_stack.pop().ok_or(Error::ENOTCAPABLE)?, + path: String::from("."), + }); + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +
+#![allow(non_camel_case_types)] +use crate::ctx::WasiCtx; +use crate::fdentry::Descriptor; +use crate::memory::*; +use crate::sys::hostcalls_impl; +use crate::{wasi, wasi32, Error, Result}; +use log::{error, trace}; +use std::convert::TryFrom; + +pub(crate) fn args_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + argv_ptr: wasi32::uintptr_t, + argv_buf: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "args_get(argv_ptr={:#x?}, argv_buf={:#x?})", + argv_ptr, + argv_buf, + ); + + let mut argv_buf_offset = 0; + let mut argv = vec![]; + + for arg in &wasi_ctx.args { + let arg_bytes = arg.as_bytes_with_nul(); + let arg_ptr = argv_buf + argv_buf_offset; + + enc_slice_of_u8(memory, arg_bytes, arg_ptr)?; + + argv.push(arg_ptr); + + let len = wasi32::uintptr_t::try_from(arg_bytes.len())?; + argv_buf_offset = argv_buf_offset.checked_add(len).ok_or(Error::EOVERFLOW)?; + } + + enc_slice_of_wasi32_uintptr(memory, argv.as_slice(), argv_ptr) +} + +pub(crate) fn args_sizes_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + argc_ptr: wasi32::uintptr_t, + argv_buf_size_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "args_sizes_get(argc_ptr={:#x?}, argv_buf_size_ptr={:#x?})", + argc_ptr, + argv_buf_size_ptr, + ); + + let argc = wasi_ctx.args.len(); + let argv_size = wasi_ctx + .args + .iter() + .map(|arg| arg.as_bytes_with_nul().len()) + .sum(); + + trace!(" | *argc_ptr={:?}", argc); + + enc_usize_byref(memory, argc_ptr, argc)?; + + trace!(" | *argv_buf_size_ptr={:?}", argv_size); + + enc_usize_byref(memory, argv_buf_size_ptr, argv_size) +} + +pub(crate) fn environ_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + environ_ptr: wasi32::uintptr_t, + environ_buf: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "environ_get(environ_ptr={:#x?}, environ_buf={:#x?})", + environ_ptr, + environ_buf, + ); + + let mut environ_buf_offset = 0; + let mut environ = vec![]; + + for pair in &wasi_ctx.env { + let env_bytes = pair.as_bytes_with_nul(); + let env_ptr = environ_buf + environ_buf_offset; + + enc_slice_of_u8(memory, env_bytes, env_ptr)?; + + environ.push(env_ptr); + + let len = wasi32::uintptr_t::try_from(env_bytes.len())?; + environ_buf_offset = environ_buf_offset + .checked_add(len) + .ok_or(Error::EOVERFLOW)?; + } + + enc_slice_of_wasi32_uintptr(memory, environ.as_slice(), environ_ptr) +} + +pub(crate) fn environ_sizes_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + environ_count_ptr: wasi32::uintptr_t, + environ_size_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "environ_sizes_get(environ_count_ptr={:#x?}, environ_size_ptr={:#x?})", + environ_count_ptr, + environ_size_ptr, + ); + + let environ_count = wasi_ctx.env.len(); + let environ_size = wasi_ctx + .env + .iter() + .try_fold(0, |acc: u32, pair| { + acc.checked_add(pair.as_bytes_with_nul().len() as u32) + }) + .ok_or(Error::EOVERFLOW)?; + + trace!(" | *environ_count_ptr={:?}", environ_count); + + enc_usize_byref(memory, environ_count_ptr, environ_count)?; + + trace!(" | *environ_size_ptr={:?}", environ_size); + + enc_usize_byref(memory, environ_size_ptr, environ_size as usize) +} + +pub(crate) fn random_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + buf_ptr: wasi32::uintptr_t, + buf_len: wasi32::size_t, +) -> Result<()> { + trace!("random_get(buf_ptr={:#x?}, buf_len={:?})", buf_ptr, buf_len); + + let buf = dec_slice_of_mut_u8(memory, buf_ptr, buf_len)?; + + getrandom::getrandom(buf).map_err(|err| { + error!("getrandom failure: {:?}", err); + Error::EIO + }) +} + +pub(crate) fn clock_res_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + clock_id: wasi::__wasi_clockid_t, + resolution_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "clock_res_get(clock_id={:?}, resolution_ptr={:#x?})", + clock_id, + resolution_ptr, + ); + + let resolution = hostcalls_impl::clock_res_get(clock_id)?; + + trace!(" | *resolution_ptr={:?}", resolution); + + enc_timestamp_byref(memory, resolution_ptr, resolution) +} + +pub(crate) fn clock_time_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + clock_id: wasi::__wasi_clockid_t, + precision: wasi::__wasi_timestamp_t, + time_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "clock_time_get(clock_id={:?}, precision={:?}, time_ptr={:#x?})", + clock_id, + precision, + time_ptr, + ); + + let time = hostcalls_impl::clock_time_get(clock_id)?; + + trace!(" | *time_ptr={:?}", time); + + enc_timestamp_byref(memory, time_ptr, time) +} + +pub(crate) fn sched_yield(_wasi_ctx: &WasiCtx, _memory: &mut [u8]) -> Result<()> { + trace!("sched_yield()"); + + std::thread::yield_now(); + + Ok(()) +} + +pub(crate) fn poll_oneoff( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + input: wasi32::uintptr_t, + output: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, + nevents: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "poll_oneoff(input={:#x?}, output={:#x?}, nsubscriptions={}, nevents={:#x?})", + input, + output, + nsubscriptions, + nevents, + ); + + if u64::from(nsubscriptions) > wasi::__wasi_filesize_t::max_value() { + return Err(Error::EINVAL); + } + + enc_int_byref(memory, nevents, 0)?; + + let subscriptions = dec_subscriptions(memory, input, nsubscriptions)?; + let mut events = Vec::new(); + + let mut timeout: Option<ClockEventData> = None; + let mut fd_events = Vec::new(); + + // As mandated by the WASI spec: + // > If `nsubscriptions` is 0, returns `errno::inval`. + if subscriptions.is_empty() { + return Err(Error::EINVAL); + } + for subscription in subscriptions { + match subscription.r#type { + wasi::__WASI_EVENTTYPE_CLOCK => { + let clock = unsafe { subscription.u.clock }; + let delay = wasi_clock_to_relative_ns_delay(clock)?; + + log::debug!("poll_oneoff event.u.clock = {:?}", clock); + log::debug!("poll_oneoff delay = {:?}ns", delay); + + let current = ClockEventData { + delay, + userdata: subscription.userdata, + }; + let timeout = timeout.get_or_insert(current); + if current.delay < timeout.delay { + *timeout = current; + } + } + r#type + if r#type == wasi::__WASI_EVENTTYPE_FD_READ + || r#type == wasi::__WASI_EVENTTYPE_FD_WRITE => + { + let wasi_fd = unsafe { subscription.u.fd_readwrite.file_descriptor }; + let rights = if r#type == wasi::__WASI_EVENTTYPE_FD_READ { + wasi::__WASI_RIGHTS_FD_READ | wasi::__WASI_RIGHTS_POLL_FD_READWRITE + } else { + wasi::__WASI_RIGHTS_FD_WRITE | wasi::__WASI_RIGHTS_POLL_FD_READWRITE + }; + + match unsafe { + wasi_ctx + .get_fd_entry(wasi_fd) + .and_then(|fe| fe.as_descriptor(rights, 0)) + } { + Ok(descriptor) => fd_events.push(FdEventData { + descriptor, + r#type: subscription.r#type, + userdata: subscription.userdata, + }), + Err(err) => { + let event = wasi::__wasi_event_t { + userdata: subscription.userdata, + r#type, + error: err.as_wasi_error().as_raw_errno(), + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: 0, + }, + }, + }; + events.push(event); + } + }; + } + _ => unreachable!(), + } + } + + log::debug!("poll_oneoff timeout = {:?}", timeout); + log::debug!("poll_oneoff fd_events = {:?}", fd_events); + + // The underlying implementation should successfully and immediately return + // if no events have been passed. Such situation may occur if all provided + // events have been filtered out as errors in the code above. + hostcalls_impl::poll_oneoff(timeout, fd_events, &mut events)?; + + let events_count = u32::try_from(events.len()).map_err(|_| Error::EOVERFLOW)?; + + enc_events(memory, output, nsubscriptions, events)?; + + trace!(" | *nevents={:?}", events_count); + + enc_int_byref(memory, nevents, events_count) +} + +fn wasi_clock_to_relative_ns_delay(wasi_clock: wasi::__wasi_subscription_clock_t) -> Result<u128> { + use std::time::SystemTime; + + if wasi_clock.flags != wasi::__WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME { + return Ok(u128::from(wasi_clock.timeout)); + } + let now: u128 = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map_err(|_| Error::ENOTCAPABLE)? + .as_nanos(); + let deadline = u128::from(wasi_clock.timeout); + Ok(deadline.saturating_sub(now)) +} + +#[derive(Debug, Copy, Clone)] +pub(crate) struct ClockEventData { + pub(crate) delay: u128, // delay is expressed in nanoseconds + pub(crate) userdata: wasi::__wasi_userdata_t, +} + +#[derive(Debug)] +pub(crate) struct FdEventData<'a> { + pub(crate) descriptor: &'a Descriptor, + pub(crate) r#type: wasi::__wasi_eventtype_t, + pub(crate) userdata: wasi::__wasi_userdata_t, +} + +pub(crate) fn proc_exit(_wasi_ctx: &WasiCtx, _memory: &mut [u8], rval: wasi::__wasi_exitcode_t) { + trace!("proc_exit(rval={:?})", rval); + // TODO: Rather than call std::process::exit here, we should trigger a + // stack unwind similar to a trap. + std::process::exit(rval as i32); +} + +pub(crate) fn proc_raise( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sig: wasi::__wasi_signal_t, +) -> Result<()> { + unimplemented!("proc_raise") +} +
1 +2 +3 +4 +5 +6 +7 +8 +9 +
+mod fs; +mod fs_helpers; +mod misc; +mod sock; + +pub(crate) use self::fs::*; +pub(crate) use self::fs_helpers::PathGet; +pub(crate) use self::misc::*; +pub(crate) use self::sock::*; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +
+use crate::ctx::WasiCtx; +use crate::{wasi, wasi32, Result}; + +pub fn sock_recv( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _ri_data: wasi32::uintptr_t, + _ri_data_len: wasi32::size_t, + _ri_flags: wasi::__wasi_riflags_t, + _ro_datalen: wasi32::uintptr_t, + _ro_flags: wasi32::uintptr_t, +) -> Result<()> { + unimplemented!("sock_recv") +} + +pub fn sock_send( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _si_data: wasi32::uintptr_t, + _si_data_len: wasi32::size_t, + _si_flags: wasi::__wasi_siflags_t, + _so_datalen: wasi32::uintptr_t, +) -> Result<()> { + unimplemented!("sock_send") +} + +pub fn sock_shutdown( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _how: wasi::__wasi_sdflags_t, +) -> Result<()> { + unimplemented!("sock_shutdown") +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +
+#![deny( + // missing_docs, + trivial_numeric_casts, + unused_extern_crates, + unstable_features, + clippy::use_self +)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../clippy.toml")))] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod ctx; +mod error; +mod fdentry; +pub mod fs; +mod helpers; +mod host; +mod hostcalls_impl; +mod memory; +pub mod old; +mod sandboxed_tty_writer; +mod sys; +pub mod wasi; +pub mod wasi32; + +pub mod hostcalls { + wig::define_hostcalls!("snapshot" "wasi_snapshot_preview1"); +} + +pub use ctx::{WasiCtx, WasiCtxBuilder}; +pub use sys::preopen_dir; + +pub use error::Error; +pub(crate) use error::Result; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +
+//! Functions to store and load data to and from wasm linear memory, +//! transforming them from and to host data types. +//! +//! Endianness concerns are completely encapsulated in this file, so +//! that users outside this file holding a `wasi::*` value never need +//! to consider what endianness it's in. Inside this file, +//! wasm linear-memory-ordered values are called "raw" values, and +//! are not held for long durations. + +#![allow(unused)] +use crate::{host, wasi, wasi32, Error, Result}; +use num::PrimInt; +use std::convert::TryFrom; +use std::mem::{align_of, size_of}; +use std::{ptr, slice}; + +fn dec_ptr(memory: &[u8], ptr: wasi32::uintptr_t, len: usize) -> Result<*const u8> { + // check for overflow + let checked_len = (ptr as usize).checked_add(len).ok_or(Error::EFAULT)?; + + // translate the pointer + memory + .get(ptr as usize..checked_len) + .ok_or(Error::EFAULT) + .map(|mem| mem.as_ptr()) +} + +fn dec_ptr_mut(memory: &mut [u8], ptr: wasi32::uintptr_t, len: usize) -> Result<*mut u8> { + // check for overflow + let checked_len = (ptr as usize).checked_add(len).ok_or(Error::EFAULT)?; + + // translate the pointer + memory + .get_mut(ptr as usize..checked_len) + .ok_or(Error::EFAULT) + .map(|mem| mem.as_mut_ptr()) +} + +fn dec_ptr_to<'memory, T>(memory: &'memory [u8], ptr: wasi32::uintptr_t) -> Result<&'memory T> { + // check that the ptr is aligned + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + + dec_ptr(memory, ptr, size_of::<T>()).map(|p| unsafe { &*(p as *const T) }) +} + +fn dec_ptr_to_mut<'memory, T>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, +) -> Result<&'memory mut T> { + // check that the ptr is aligned + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + + dec_ptr_mut(memory, ptr, size_of::<T>()).map(|p| unsafe { &mut *(p as *mut T) }) +} + +/// This function does not perform endianness conversions! +fn dec_raw_byref<T>(memory: &[u8], ptr: wasi32::uintptr_t) -> Result<T> { + dec_ptr_to::<T>(memory, ptr).map(|p| unsafe { ptr::read(p) }) +} + +/// This function does not perform endianness conversions! +fn enc_raw_byref<T>(memory: &mut [u8], ptr: wasi32::uintptr_t, t: T) -> Result<()> { + dec_ptr_to_mut::<T>(memory, ptr).map(|p| unsafe { ptr::write(p, t) }) +} + +pub(crate) fn dec_int_byref<T>(memory: &[u8], ptr: wasi32::uintptr_t) -> Result<T> +where + T: PrimInt, +{ + dec_raw_byref::<T>(memory, ptr).map(|i| PrimInt::from_le(i)) +} + +pub(crate) fn enc_int_byref<T>(memory: &mut [u8], ptr: wasi32::uintptr_t, t: T) -> Result<()> +where + T: PrimInt, +{ + enc_raw_byref::<T>(memory, ptr, PrimInt::to_le(t)) +} + +fn check_slice_of<T>(ptr: wasi32::uintptr_t, len: wasi32::size_t) -> Result<(usize, usize)> { + // check alignment, and that length doesn't overflow + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + let len = dec_usize(len); + let len_bytes = if let Some(len) = size_of::<T>().checked_mul(len) { + len + } else { + return Err(Error::EOVERFLOW); + }; + + Ok((len, len_bytes)) +} + +fn dec_raw_slice_of<'memory, T>( + memory: &'memory [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory [T]> { + let (len, len_bytes) = check_slice_of::<T>(ptr, len)?; + let ptr = dec_ptr(memory, ptr, len_bytes)? as *const T; + Ok(unsafe { slice::from_raw_parts(ptr, len) }) +} + +fn dec_raw_slice_of_mut<'memory, T>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory mut [T]> { + let (len, len_bytes) = check_slice_of::<T>(ptr, len)?; + let ptr = dec_ptr_mut(memory, ptr, len_bytes)? as *mut T; + Ok(unsafe { slice::from_raw_parts_mut(ptr, len) }) +} + +fn raw_slice_for_enc<'memory, T>( + memory: &'memory mut [u8], + slice: &[T], + ptr: wasi32::uintptr_t, +) -> Result<&'memory mut [T]> { + // check alignment + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + // check that length doesn't overflow + let len_bytes = if let Some(len) = size_of::<T>().checked_mul(slice.len()) { + len + } else { + return Err(Error::EOVERFLOW); + }; + + // get the pointer into guest memory + let ptr = dec_ptr_mut(memory, ptr, len_bytes)? as *mut T; + + Ok(unsafe { slice::from_raw_parts_mut(ptr, slice.len()) }) +} + +pub(crate) fn dec_slice_of_u8<'memory>( + memory: &'memory [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory [u8]> { + dec_raw_slice_of::<u8>(memory, ptr, len) +} + +pub(crate) fn dec_slice_of_mut_u8<'memory>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory mut [u8]> { + dec_raw_slice_of_mut::<u8>(memory, ptr, len) +} + +pub(crate) fn enc_slice_of_u8( + memory: &mut [u8], + slice: &[u8], + ptr: wasi32::uintptr_t, +) -> Result<()> { + let output = raw_slice_for_enc::<u8>(memory, slice, ptr)?; + + output.copy_from_slice(slice); + + Ok(()) +} + +pub(crate) fn enc_slice_of_wasi32_uintptr( + memory: &mut [u8], + slice: &[wasi32::uintptr_t], + ptr: wasi32::uintptr_t, +) -> Result<()> { + let mut output_iter = raw_slice_for_enc::<wasi32::uintptr_t>(memory, slice, ptr)?.into_iter(); + + for p in slice { + *output_iter.next().unwrap() = PrimInt::to_le(*p); + } + + Ok(()) +} + +macro_rules! dec_enc_scalar { + ($ty:ident, $dec_byref:ident, $enc_byref:ident) => { + pub(crate) fn $dec_byref(memory: &mut [u8], ptr: wasi32::uintptr_t) -> Result<wasi::$ty> { + dec_int_byref::<wasi::$ty>(memory, ptr) + } + + pub(crate) fn $enc_byref( + memory: &mut [u8], + ptr: wasi32::uintptr_t, + x: wasi::$ty, + ) -> Result<()> { + enc_int_byref::<wasi::$ty>(memory, ptr, x) + } + }; +} + +pub(crate) fn dec_ciovec_slice( + memory: &[u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<Vec<host::__wasi_ciovec_t>> { + let raw_slice = dec_raw_slice_of::<wasi32::__wasi_ciovec_t>(memory, ptr, len)?; + + raw_slice + .iter() + .map(|raw_iov| { + let len = dec_usize(PrimInt::from_le(raw_iov.buf_len)); + let buf = PrimInt::from_le(raw_iov.buf); + Ok(host::__wasi_ciovec_t { + buf: dec_ptr(memory, buf, len)? as *const u8, + buf_len: len, + }) + }) + .collect() +} + +pub(crate) fn dec_iovec_slice( + memory: &[u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<Vec<host::__wasi_iovec_t>> { + let raw_slice = dec_raw_slice_of::<wasi32::__wasi_iovec_t>(memory, ptr, len)?; + + raw_slice + .iter() + .map(|raw_iov| { + let len = dec_usize(PrimInt::from_le(raw_iov.buf_len)); + let buf = PrimInt::from_le(raw_iov.buf); + Ok(host::__wasi_iovec_t { + buf: dec_ptr(memory, buf, len)? as *mut u8, + buf_len: len, + }) + }) + .collect() +} + +dec_enc_scalar!(__wasi_clockid_t, dec_clockid_byref, enc_clockid_byref); +dec_enc_scalar!(__wasi_errno_t, dec_errno_byref, enc_errno_byref); +dec_enc_scalar!(__wasi_exitcode_t, dec_exitcode_byref, enc_exitcode_byref); +dec_enc_scalar!(__wasi_fd_t, dec_fd_byref, enc_fd_byref); +dec_enc_scalar!(__wasi_fdflags_t, dec_fdflags_byref, enc_fdflags_byref); +dec_enc_scalar!(__wasi_device_t, dev_device_byref, enc_device_byref); +dec_enc_scalar!(__wasi_inode_t, dev_inode_byref, enc_inode_byref); +dec_enc_scalar!(__wasi_linkcount_t, dev_linkcount_byref, enc_linkcount_byref); + +pub(crate) fn dec_filestat_byref( + memory: &mut [u8], + filestat_ptr: wasi32::uintptr_t, +) -> Result<wasi::__wasi_filestat_t> { + let raw = dec_raw_byref::<wasi::__wasi_filestat_t>(memory, filestat_ptr)?; + + Ok(wasi::__wasi_filestat_t { + dev: PrimInt::from_le(raw.dev), + ino: PrimInt::from_le(raw.ino), + filetype: PrimInt::from_le(raw.filetype), + nlink: PrimInt::from_le(raw.nlink), + size: PrimInt::from_le(raw.size), + atim: PrimInt::from_le(raw.atim), + mtim: PrimInt::from_le(raw.mtim), + ctim: PrimInt::from_le(raw.ctim), + }) +} + +pub(crate) fn enc_filestat_byref( + memory: &mut [u8], + filestat_ptr: wasi32::uintptr_t, + filestat: wasi::__wasi_filestat_t, +) -> Result<()> { + let raw = wasi::__wasi_filestat_t { + dev: PrimInt::to_le(filestat.dev), + ino: PrimInt::to_le(filestat.ino), + filetype: PrimInt::to_le(filestat.filetype), + nlink: PrimInt::to_le(filestat.nlink), + size: PrimInt::to_le(filestat.size), + atim: PrimInt::to_le(filestat.atim), + mtim: PrimInt::to_le(filestat.mtim), + ctim: PrimInt::to_le(filestat.ctim), + }; + + enc_raw_byref::<wasi::__wasi_filestat_t>(memory, filestat_ptr, raw) +} + +pub(crate) fn dec_fdstat_byref( + memory: &mut [u8], + fdstat_ptr: wasi32::uintptr_t, +) -> Result<wasi::__wasi_fdstat_t> { + let raw = dec_raw_byref::<wasi::__wasi_fdstat_t>(memory, fdstat_ptr)?; + + Ok(wasi::__wasi_fdstat_t { + fs_filetype: PrimInt::from_le(raw.fs_filetype), + fs_flags: PrimInt::from_le(raw.fs_flags), + fs_rights_base: PrimInt::from_le(raw.fs_rights_base), + fs_rights_inheriting: PrimInt::from_le(raw.fs_rights_inheriting), + }) +} + +pub(crate) fn enc_fdstat_byref( + memory: &mut [u8], + fdstat_ptr: wasi32::uintptr_t, + fdstat: wasi::__wasi_fdstat_t, +) -> Result<()> { + let raw = wasi::__wasi_fdstat_t { + fs_filetype: PrimInt::to_le(fdstat.fs_filetype), + fs_flags: PrimInt::to_le(fdstat.fs_flags), + fs_rights_base: PrimInt::to_le(fdstat.fs_rights_base), + fs_rights_inheriting: PrimInt::to_le(fdstat.fs_rights_inheriting), + }; + + enc_raw_byref::<wasi::__wasi_fdstat_t>(memory, fdstat_ptr, raw) +} + +dec_enc_scalar!(__wasi_filedelta_t, dec_filedelta_byref, enc_filedelta_byref); +dec_enc_scalar!(__wasi_filesize_t, dec_filesize_byref, enc_filesize_byref); +dec_enc_scalar!(__wasi_filetype_t, dec_filetype_byref, enc_filetype_byref); + +dec_enc_scalar!( + __wasi_lookupflags_t, + dec_lookupflags_byref, + enc_lookupflags_byref +); + +dec_enc_scalar!(__wasi_oflags_t, dec_oflags_byref, enc_oflags_byref); + +pub(crate) fn dec_prestat_byref( + memory: &mut [u8], + prestat_ptr: wasi32::uintptr_t, +) -> Result<host::__wasi_prestat_t> { + let raw = dec_raw_byref::<wasi32::__wasi_prestat_t>(memory, prestat_ptr)?; + + match PrimInt::from_le(raw.pr_type) { + wasi::__WASI_PREOPENTYPE_DIR => Ok(host::__wasi_prestat_t { + pr_type: wasi::__WASI_PREOPENTYPE_DIR, + u: host::__wasi_prestat_u_t { + dir: host::__wasi_prestat_dir_t { + pr_name_len: dec_usize(PrimInt::from_le(unsafe { raw.u.dir.pr_name_len })), + }, + }, + }), + _ => Err(Error::EINVAL), + } +} + +pub(crate) fn enc_prestat_byref( + memory: &mut [u8], + prestat_ptr: wasi32::uintptr_t, + prestat: host::__wasi_prestat_t, +) -> Result<()> { + let raw = match prestat.pr_type { + wasi::__WASI_PREOPENTYPE_DIR => Ok(wasi32::__wasi_prestat_t { + pr_type: PrimInt::to_le(wasi::__WASI_PREOPENTYPE_DIR), + u: wasi32::__wasi_prestat_u_t { + dir: wasi32::__wasi_prestat_dir_t { + pr_name_len: enc_usize(unsafe { prestat.u.dir.pr_name_len }), + }, + }, + }), + _ => Err(Error::EINVAL), + }?; + + enc_raw_byref::<wasi32::__wasi_prestat_t>(memory, prestat_ptr, raw) +} + +dec_enc_scalar!(__wasi_rights_t, dec_rights_byref, enc_rights_byref); +dec_enc_scalar!(__wasi_timestamp_t, dec_timestamp_byref, enc_timestamp_byref); + +pub(crate) fn dec_usize(size: wasi32::size_t) -> usize { + usize::try_from(size).unwrap() +} + +pub(crate) fn enc_usize(size: usize) -> wasi32::size_t { + wasi32::size_t::try_from(size).unwrap() +} + +pub(crate) fn enc_usize_byref( + memory: &mut [u8], + usize_ptr: wasi32::uintptr_t, + host_usize: usize, +) -> Result<()> { + enc_int_byref::<wasi32::size_t>(memory, usize_ptr, enc_usize(host_usize)) +} + +dec_enc_scalar!(__wasi_whence_t, dec_whence_byref, enc_whence_byref); + +dec_enc_scalar!( + __wasi_subclockflags_t, + dec_subclockflags_byref, + enc_subclockflags_byref +); + +dec_enc_scalar!( + __wasi_eventrwflags_t, + dec_eventrwflags_byref, + enc_eventrwflags_byref +); + +dec_enc_scalar!(__wasi_eventtype_t, dec_eventtype_byref, enc_eventtype_byref); +dec_enc_scalar!(__wasi_userdata_t, dec_userdata_byref, enc_userdata_byref); + +pub(crate) fn dec_subscriptions( + memory: &mut [u8], + input: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, +) -> Result<Vec<wasi::__wasi_subscription_t>> { + let raw_input_slice = + dec_raw_slice_of::<wasi::__wasi_subscription_t>(memory, input, nsubscriptions)?; + + raw_input_slice + .into_iter() + .map(|raw_subscription| { + let userdata = PrimInt::from_le(raw_subscription.userdata); + let r#type = PrimInt::from_le(raw_subscription.r#type); + let raw_u = raw_subscription.u; + let u = match r#type { + wasi::__WASI_EVENTTYPE_CLOCK => wasi::__wasi_subscription_u_t { + clock: unsafe { + wasi::__wasi_subscription_clock_t { + id: PrimInt::from_le(raw_u.clock.id), + timeout: PrimInt::from_le(raw_u.clock.timeout), + precision: PrimInt::from_le(raw_u.clock.precision), + flags: PrimInt::from_le(raw_u.clock.flags), + } + }, + }, + wasi::__WASI_EVENTTYPE_FD_READ | wasi::__WASI_EVENTTYPE_FD_WRITE => { + wasi::__wasi_subscription_u_t { + fd_readwrite: wasi::__wasi_subscription_fd_readwrite_t { + file_descriptor: PrimInt::from_le(unsafe { + raw_u.fd_readwrite.file_descriptor + }), + }, + } + } + _ => return Err(Error::EINVAL), + }; + Ok(wasi::__wasi_subscription_t { + userdata, + r#type, + u, + }) + }) + .collect::<Result<Vec<_>>>() +} + +pub(crate) fn enc_events( + memory: &mut [u8], + output: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, + events: Vec<wasi::__wasi_event_t>, +) -> Result<()> { + let mut raw_output_iter = + dec_raw_slice_of_mut::<wasi::__wasi_event_t>(memory, output, nsubscriptions)?.into_iter(); + + for event in events.iter() { + *raw_output_iter + .next() + .expect("the number of events cannot exceed the number of subscriptions") = { + let fd_readwrite = unsafe { event.u.fd_readwrite }; + wasi::__wasi_event_t { + userdata: PrimInt::to_le(event.userdata), + r#type: PrimInt::to_le(event.r#type), + error: PrimInt::to_le(event.error), + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: PrimInt::to_le(fd_readwrite.nbytes), + flags: PrimInt::to_le(fd_readwrite.flags), + }, + }, + } + }; + } + + Ok(()) +} + +dec_enc_scalar!(__wasi_advice_t, dec_advice_byref, enc_advice_byref); +dec_enc_scalar!(__wasi_fstflags_t, dec_fstflags_byref, enc_fstflags_byref); +dec_enc_scalar!(__wasi_dircookie_t, dec_dircookie_byref, enc_dircookie_byref); +
1
++pub mod snapshot_0; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +
+use crate::old::snapshot_0::fdentry::FdEntry; +use crate::old::snapshot_0::{wasi, Error, Result}; +use std::borrow::Borrow; +use std::collections::HashMap; +use std::env; +use std::ffi::{CString, OsString}; +use std::fs::File; +use std::path::{Path, PathBuf}; + +enum PendingFdEntry { + Thunk(fn() -> Result<FdEntry>), + File(File), +} + +impl std::fmt::Debug for PendingFdEntry { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Thunk(f) => write!( + fmt, + "PendingFdEntry::Thunk({:p})", + f as *const fn() -> Result<FdEntry> + ), + Self::File(f) => write!(fmt, "PendingFdEntry::File({:?})", f), + } + } +} + +#[derive(Debug, Eq, Hash, PartialEq)] +enum PendingCString { + Bytes(Vec<u8>), + OsString(OsString), +} + +impl From<Vec<u8>> for PendingCString { + fn from(bytes: Vec<u8>) -> Self { + Self::Bytes(bytes) + } +} + +impl From<OsString> for PendingCString { + fn from(s: OsString) -> Self { + Self::OsString(s) + } +} + +impl PendingCString { + fn into_string(self) -> Result<String> { + match self { + Self::Bytes(v) => String::from_utf8(v).map_err(|_| Error::EILSEQ), + Self::OsString(s) => s.into_string().map_err(|_| Error::EILSEQ), + } + } + + /// Create a `CString` containing valid UTF-8, or fail with `Error::EILSEQ`. + fn into_utf8_cstring(self) -> Result<CString> { + self.into_string() + .and_then(|s| CString::new(s).map_err(|_| Error::EILSEQ)) + } +} + +/// A builder allowing customizable construction of `WasiCtx` instances. +pub struct WasiCtxBuilder { + fds: HashMap<wasi::__wasi_fd_t, PendingFdEntry>, + preopens: Vec<(PathBuf, File)>, + args: Vec<PendingCString>, + env: HashMap<PendingCString, PendingCString>, +} + +impl WasiCtxBuilder { + /// Builder for a new `WasiCtx`. + pub fn new() -> Self { + let mut builder = Self { + fds: HashMap::new(), + preopens: Vec::new(), + args: vec![], + env: HashMap::new(), + }; + + builder.fds.insert(0, PendingFdEntry::Thunk(FdEntry::null)); + builder.fds.insert(1, PendingFdEntry::Thunk(FdEntry::null)); + builder.fds.insert(2, PendingFdEntry::Thunk(FdEntry::null)); + + builder + } + + /// Add arguments to the command-line arguments list. + /// + /// Arguments must be valid UTF-8 with no NUL bytes, or else `WasiCtxBuilder::build()` will fail + /// with `Error::EILSEQ`. + pub fn args<S: AsRef<[u8]>>(mut self, args: impl IntoIterator<Item = S>) -> Self { + self.args = args + .into_iter() + .map(|arg| arg.as_ref().to_vec().into()) + .collect(); + self + } + + /// Add an argument to the command-line arguments list. + /// + /// Arguments must be valid UTF-8 with no NUL bytes, or else `WasiCtxBuilder::build()` will fail + /// with `Error::EILSEQ`. + pub fn arg<S: AsRef<[u8]>>(mut self, arg: S) -> Self { + self.args.push(arg.as_ref().to_vec().into()); + self + } + + /// Inherit the command-line arguments from the host process. + /// + /// If any arguments from the host process contain invalid UTF-8, `WasiCtxBuilder::build()` will + /// fail with `Error::EILSEQ`. + pub fn inherit_args(mut self) -> Self { + self.args = env::args_os().map(PendingCString::OsString).collect(); + self + } + + /// Inherit the stdin, stdout, and stderr streams from the host process. + pub fn inherit_stdio(mut self) -> Self { + self.fds + .insert(0, PendingFdEntry::Thunk(FdEntry::duplicate_stdin)); + self.fds + .insert(1, PendingFdEntry::Thunk(FdEntry::duplicate_stdout)); + self.fds + .insert(2, PendingFdEntry::Thunk(FdEntry::duplicate_stderr)); + self + } + + /// Inherit the environment variables from the host process. + /// + /// If any environment variables from the host process contain invalid Unicode (UTF-16 for + /// Windows, UTF-8 for other platforms), `WasiCtxBuilder::build()` will fail with + /// `Error::EILSEQ`. + pub fn inherit_env(mut self) -> Self { + self.env = std::env::vars_os() + .map(|(k, v)| (k.into(), v.into())) + .collect(); + self + } + + /// Add an entry to the environment. + /// + /// Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else + /// `WasiCtxBuilder::build()` will fail with `Error::EILSEQ`. + pub fn env<S: AsRef<[u8]>>(mut self, k: S, v: S) -> Self { + self.env + .insert(k.as_ref().to_vec().into(), v.as_ref().to_vec().into()); + self + } + + /// Add entries to the environment. + /// + /// Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else + /// `WasiCtxBuilder::build()` will fail with `Error::EILSEQ`. + pub fn envs<S: AsRef<[u8]>, T: Borrow<(S, S)>>( + mut self, + envs: impl IntoIterator<Item = T>, + ) -> Self { + self.env = envs + .into_iter() + .map(|t| { + let (k, v) = t.borrow(); + (k.as_ref().to_vec().into(), v.as_ref().to_vec().into()) + }) + .collect(); + self + } + + /// Provide a File to use as stdin + pub fn stdin(mut self, file: File) -> Self { + self.fds.insert(0, PendingFdEntry::File(file)); + self + } + + /// Provide a File to use as stdout + pub fn stdout(mut self, file: File) -> Self { + self.fds.insert(1, PendingFdEntry::File(file)); + self + } + + /// Provide a File to use as stderr + pub fn stderr(mut self, file: File) -> Self { + self.fds.insert(2, PendingFdEntry::File(file)); + self + } + + /// Add a preopened directory. + pub fn preopened_dir<P: AsRef<Path>>(mut self, dir: File, guest_path: P) -> Self { + self.preopens.push((guest_path.as_ref().to_owned(), dir)); + self + } + + /// Build a `WasiCtx`, consuming this `WasiCtxBuilder`. + /// + /// If any of the arguments or environment variables in this builder cannot be converted into + /// `CString`s, either due to NUL bytes or Unicode conversions, this returns `Error::EILSEQ`. + pub fn build(self) -> Result<WasiCtx> { + // Process arguments and environment variables into `CString`s, failing quickly if they + // contain any NUL bytes, or if conversion from `OsString` fails. + let args = self + .args + .into_iter() + .map(|arg| arg.into_utf8_cstring()) + .collect::<Result<Vec<CString>>>()?; + + let env = self + .env + .into_iter() + .map(|(k, v)| { + k.into_string().and_then(|mut pair| { + v.into_string().and_then(|v| { + pair.push('='); + pair.push_str(v.as_str()); + // We have valid UTF-8, but the keys and values have not yet been checked + // for NULs, so we do a final check here. + CString::new(pair).map_err(|_| Error::EILSEQ) + }) + }) + }) + .collect::<Result<Vec<CString>>>()?; + + let mut fds: HashMap<wasi::__wasi_fd_t, FdEntry> = HashMap::new(); + // Populate the non-preopen fds. + for (fd, pending) in self.fds { + log::debug!("WasiCtx inserting ({:?}, {:?})", fd, pending); + match pending { + PendingFdEntry::Thunk(f) => { + fds.insert(fd, f()?); + } + PendingFdEntry::File(f) => { + fds.insert(fd, FdEntry::from(f)?); + } + } + } + // Then add the preopen fds. Startup code in the guest starts looking at fd 3 for preopens, + // so we start from there. This variable is initially 2, though, because the loop + // immediately does the increment and check for overflow. + let mut preopen_fd: wasi::__wasi_fd_t = 2; + for (guest_path, dir) in self.preopens { + // We do the increment at the beginning of the loop body, so that we don't overflow + // unnecessarily if we have exactly the maximum number of file descriptors. + preopen_fd = preopen_fd.checked_add(1).ok_or(Error::ENFILE)?; + + if !dir.metadata()?.is_dir() { + return Err(Error::EBADF); + } + + // We don't currently allow setting file descriptors other than 0-2, but this will avoid + // collisions if we restore that functionality in the future. + while fds.contains_key(&preopen_fd) { + preopen_fd = preopen_fd.checked_add(1).ok_or(Error::ENFILE)?; + } + let mut fe = FdEntry::from(dir)?; + fe.preopen_path = Some(guest_path); + log::debug!("WasiCtx inserting ({:?}, {:?})", preopen_fd, fe); + fds.insert(preopen_fd, fe); + log::debug!("WasiCtx fds = {:?}", fds); + } + + Ok(WasiCtx { args, env, fds }) + } +} + +#[derive(Debug)] +pub struct WasiCtx { + fds: HashMap<wasi::__wasi_fd_t, FdEntry>, + pub(crate) args: Vec<CString>, + pub(crate) env: Vec<CString>, +} + +impl WasiCtx { + /// Make a new `WasiCtx` with some default settings. + /// + /// - File descriptors 0, 1, and 2 inherit stdin, stdout, and stderr from the host process. + /// + /// - Environment variables are inherited from the host process. + /// + /// To override these behaviors, use `WasiCtxBuilder`. + pub fn new<S: AsRef<[u8]>>(args: impl IntoIterator<Item = S>) -> Result<Self> { + WasiCtxBuilder::new() + .args(args) + .inherit_stdio() + .inherit_env() + .build() + } + + /// Check if `WasiCtx` contains the specified raw WASI `fd`. + pub(crate) unsafe fn contains_fd_entry(&self, fd: wasi::__wasi_fd_t) -> bool { + self.fds.contains_key(&fd) + } + + /// Get an immutable `FdEntry` corresponding to the specified raw WASI `fd`. + pub(crate) unsafe fn get_fd_entry(&self, fd: wasi::__wasi_fd_t) -> Result<&FdEntry> { + self.fds.get(&fd).ok_or(Error::EBADF) + } + + /// Get a mutable `FdEntry` corresponding to the specified raw WASI `fd`. + pub(crate) unsafe fn get_fd_entry_mut( + &mut self, + fd: wasi::__wasi_fd_t, + ) -> Result<&mut FdEntry> { + self.fds.get_mut(&fd).ok_or(Error::EBADF) + } + + /// Insert the specified `FdEntry` into the `WasiCtx` object. + /// + /// The `FdEntry` will automatically get another free raw WASI `fd` assigned. Note that + /// the two subsequent free raw WASI `fd`s do not have to be stored contiguously. + pub(crate) fn insert_fd_entry(&mut self, fe: FdEntry) -> Result<wasi::__wasi_fd_t> { + // Never insert where stdio handles are expected to be. + let mut fd = 3; + while self.fds.contains_key(&fd) { + if let Some(next_fd) = fd.checked_add(1) { + fd = next_fd; + } else { + return Err(Error::EMFILE); + } + } + self.fds.insert(fd, fe); + Ok(fd) + } + + /// Insert the specified `FdEntry` with the specified raw WASI `fd` key into the `WasiCtx` + /// object. + pub(crate) fn insert_fd_entry_at( + &mut self, + fd: wasi::__wasi_fd_t, + fe: FdEntry, + ) -> Option<FdEntry> { + self.fds.insert(fd, fe) + } + + /// Remove `FdEntry` corresponding to the specified raw WASI `fd` from the `WasiCtx` object. + pub(crate) fn remove_fd_entry(&mut self, fd: wasi::__wasi_fd_t) -> Result<FdEntry> { + self.fds.remove(&fd).ok_or(Error::EBADF) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +
+// Due to https://github.com/rust-lang/rust/issues/64247 +#![allow(clippy::use_self)] +use crate::old::snapshot_0::wasi; +use std::convert::Infallible; +use std::num::TryFromIntError; +use std::{ffi, str}; +use thiserror::Error; + +#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)] +#[repr(u16)] +#[error("{:?} ({})", self, wasi::strerror(*self as wasi::__wasi_errno_t))] +pub enum WasiError { + ESUCCESS = wasi::__WASI_ERRNO_SUCCESS, + E2BIG = wasi::__WASI_ERRNO_2BIG, + EACCES = wasi::__WASI_ERRNO_ACCES, + EADDRINUSE = wasi::__WASI_ERRNO_ADDRINUSE, + EADDRNOTAVAIL = wasi::__WASI_ERRNO_ADDRNOTAVAIL, + EAFNOSUPPORT = wasi::__WASI_ERRNO_AFNOSUPPORT, + EAGAIN = wasi::__WASI_ERRNO_AGAIN, + EALREADY = wasi::__WASI_ERRNO_ALREADY, + EBADF = wasi::__WASI_ERRNO_BADF, + EBADMSG = wasi::__WASI_ERRNO_BADMSG, + EBUSY = wasi::__WASI_ERRNO_BUSY, + ECANCELED = wasi::__WASI_ERRNO_CANCELED, + ECHILD = wasi::__WASI_ERRNO_CHILD, + ECONNABORTED = wasi::__WASI_ERRNO_CONNABORTED, + ECONNREFUSED = wasi::__WASI_ERRNO_CONNREFUSED, + ECONNRESET = wasi::__WASI_ERRNO_CONNRESET, + EDEADLK = wasi::__WASI_ERRNO_DEADLK, + EDESTADDRREQ = wasi::__WASI_ERRNO_DESTADDRREQ, + EDOM = wasi::__WASI_ERRNO_DOM, + EDQUOT = wasi::__WASI_ERRNO_DQUOT, + EEXIST = wasi::__WASI_ERRNO_EXIST, + EFAULT = wasi::__WASI_ERRNO_FAULT, + EFBIG = wasi::__WASI_ERRNO_FBIG, + EHOSTUNREACH = wasi::__WASI_ERRNO_HOSTUNREACH, + EIDRM = wasi::__WASI_ERRNO_IDRM, + EILSEQ = wasi::__WASI_ERRNO_ILSEQ, + EINPROGRESS = wasi::__WASI_ERRNO_INPROGRESS, + EINTR = wasi::__WASI_ERRNO_INTR, + EINVAL = wasi::__WASI_ERRNO_INVAL, + EIO = wasi::__WASI_ERRNO_IO, + EISCONN = wasi::__WASI_ERRNO_ISCONN, + EISDIR = wasi::__WASI_ERRNO_ISDIR, + ELOOP = wasi::__WASI_ERRNO_LOOP, + EMFILE = wasi::__WASI_ERRNO_MFILE, + EMLINK = wasi::__WASI_ERRNO_MLINK, + EMSGSIZE = wasi::__WASI_ERRNO_MSGSIZE, + EMULTIHOP = wasi::__WASI_ERRNO_MULTIHOP, + ENAMETOOLONG = wasi::__WASI_ERRNO_NAMETOOLONG, + ENETDOWN = wasi::__WASI_ERRNO_NETDOWN, + ENETRESET = wasi::__WASI_ERRNO_NETRESET, + ENETUNREACH = wasi::__WASI_ERRNO_NETUNREACH, + ENFILE = wasi::__WASI_ERRNO_NFILE, + ENOBUFS = wasi::__WASI_ERRNO_NOBUFS, + ENODEV = wasi::__WASI_ERRNO_NODEV, + ENOENT = wasi::__WASI_ERRNO_NOENT, + ENOEXEC = wasi::__WASI_ERRNO_NOEXEC, + ENOLCK = wasi::__WASI_ERRNO_NOLCK, + ENOLINK = wasi::__WASI_ERRNO_NOLINK, + ENOMEM = wasi::__WASI_ERRNO_NOMEM, + ENOMSG = wasi::__WASI_ERRNO_NOMSG, + ENOPROTOOPT = wasi::__WASI_ERRNO_NOPROTOOPT, + ENOSPC = wasi::__WASI_ERRNO_NOSPC, + ENOSYS = wasi::__WASI_ERRNO_NOSYS, + ENOTCONN = wasi::__WASI_ERRNO_NOTCONN, + ENOTDIR = wasi::__WASI_ERRNO_NOTDIR, + ENOTEMPTY = wasi::__WASI_ERRNO_NOTEMPTY, + ENOTRECOVERABLE = wasi::__WASI_ERRNO_NOTRECOVERABLE, + ENOTSOCK = wasi::__WASI_ERRNO_NOTSOCK, + ENOTSUP = wasi::__WASI_ERRNO_NOTSUP, + ENOTTY = wasi::__WASI_ERRNO_NOTTY, + ENXIO = wasi::__WASI_ERRNO_NXIO, + EOVERFLOW = wasi::__WASI_ERRNO_OVERFLOW, + EOWNERDEAD = wasi::__WASI_ERRNO_OWNERDEAD, + EPERM = wasi::__WASI_ERRNO_PERM, + EPIPE = wasi::__WASI_ERRNO_PIPE, + EPROTO = wasi::__WASI_ERRNO_PROTO, + EPROTONOSUPPORT = wasi::__WASI_ERRNO_PROTONOSUPPORT, + EPROTOTYPE = wasi::__WASI_ERRNO_PROTOTYPE, + ERANGE = wasi::__WASI_ERRNO_RANGE, + EROFS = wasi::__WASI_ERRNO_ROFS, + ESPIPE = wasi::__WASI_ERRNO_SPIPE, + ESRCH = wasi::__WASI_ERRNO_SRCH, + ESTALE = wasi::__WASI_ERRNO_STALE, + ETIMEDOUT = wasi::__WASI_ERRNO_TIMEDOUT, + ETXTBSY = wasi::__WASI_ERRNO_TXTBSY, + EXDEV = wasi::__WASI_ERRNO_XDEV, + ENOTCAPABLE = wasi::__WASI_ERRNO_NOTCAPABLE, +} + +impl WasiError { + pub fn as_raw_errno(self) -> wasi::__wasi_errno_t { + self as wasi::__wasi_errno_t + } +} + +#[derive(Debug, Error)] +pub enum Error { + #[error("WASI error code: {0}")] + Wasi(#[from] WasiError), + #[error("IO error: {0}")] + Io(#[from] std::io::Error), + #[cfg(unix)] + #[error("Yanix error: {0}")] + Yanix(#[from] yanix::YanixError), +} + +impl From<TryFromIntError> for Error { + fn from(_: TryFromIntError) -> Self { + Self::EOVERFLOW + } +} + +impl From<Infallible> for Error { + fn from(_: Infallible) -> Self { + unreachable!() + } +} + +impl From<str::Utf8Error> for Error { + fn from(_: str::Utf8Error) -> Self { + Self::EILSEQ + } +} + +impl From<ffi::NulError> for Error { + fn from(_: ffi::NulError) -> Self { + Self::EILSEQ + } +} + +impl From<&ffi::NulError> for Error { + fn from(_: &ffi::NulError) -> Self { + Self::EILSEQ + } +} + +impl Error { + pub(crate) fn as_wasi_error(&self) -> WasiError { + match self { + Self::Wasi(err) => *err, + Self::Io(err) => { + let err = match err.raw_os_error() { + Some(code) => Self::from_raw_os_error(code), + None => { + log::debug!("Inconvertible OS error: {}", err); + Self::EIO + } + }; + err.as_wasi_error() + } + #[cfg(unix)] + Self::Yanix(err) => { + use yanix::YanixError::*; + let err: Self = match err { + Errno(errno) => (*errno).into(), + NulError(err) => err.into(), + TryFromIntError(err) => (*err).into(), + }; + err.as_wasi_error() + } + } + } + + pub const ESUCCESS: Self = Error::Wasi(WasiError::ESUCCESS); + pub const E2BIG: Self = Error::Wasi(WasiError::E2BIG); + pub const EACCES: Self = Error::Wasi(WasiError::EACCES); + pub const EADDRINUSE: Self = Error::Wasi(WasiError::EADDRINUSE); + pub const EADDRNOTAVAIL: Self = Error::Wasi(WasiError::EADDRNOTAVAIL); + pub const EAFNOSUPPORT: Self = Error::Wasi(WasiError::EAFNOSUPPORT); + pub const EAGAIN: Self = Error::Wasi(WasiError::EAGAIN); + pub const EALREADY: Self = Error::Wasi(WasiError::EALREADY); + pub const EBADF: Self = Error::Wasi(WasiError::EBADF); + pub const EBADMSG: Self = Error::Wasi(WasiError::EBADMSG); + pub const EBUSY: Self = Error::Wasi(WasiError::EBUSY); + pub const ECANCELED: Self = Error::Wasi(WasiError::ECANCELED); + pub const ECHILD: Self = Error::Wasi(WasiError::ECHILD); + pub const ECONNABORTED: Self = Error::Wasi(WasiError::ECONNABORTED); + pub const ECONNREFUSED: Self = Error::Wasi(WasiError::ECONNREFUSED); + pub const ECONNRESET: Self = Error::Wasi(WasiError::ECONNRESET); + pub const EDEADLK: Self = Error::Wasi(WasiError::EDEADLK); + pub const EDESTADDRREQ: Self = Error::Wasi(WasiError::EDESTADDRREQ); + pub const EDOM: Self = Error::Wasi(WasiError::EDOM); + pub const EDQUOT: Self = Error::Wasi(WasiError::EDQUOT); + pub const EEXIST: Self = Error::Wasi(WasiError::EEXIST); + pub const EFAULT: Self = Error::Wasi(WasiError::EFAULT); + pub const EFBIG: Self = Error::Wasi(WasiError::EFBIG); + pub const EHOSTUNREACH: Self = Error::Wasi(WasiError::EHOSTUNREACH); + pub const EIDRM: Self = Error::Wasi(WasiError::EIDRM); + pub const EILSEQ: Self = Error::Wasi(WasiError::EILSEQ); + pub const EINPROGRESS: Self = Error::Wasi(WasiError::EINPROGRESS); + pub const EINTR: Self = Error::Wasi(WasiError::EINTR); + pub const EINVAL: Self = Error::Wasi(WasiError::EINVAL); + pub const EIO: Self = Error::Wasi(WasiError::EIO); + pub const EISCONN: Self = Error::Wasi(WasiError::EISCONN); + pub const EISDIR: Self = Error::Wasi(WasiError::EISDIR); + pub const ELOOP: Self = Error::Wasi(WasiError::ELOOP); + pub const EMFILE: Self = Error::Wasi(WasiError::EMFILE); + pub const EMLINK: Self = Error::Wasi(WasiError::EMLINK); + pub const EMSGSIZE: Self = Error::Wasi(WasiError::EMSGSIZE); + pub const EMULTIHOP: Self = Error::Wasi(WasiError::EMULTIHOP); + pub const ENAMETOOLONG: Self = Error::Wasi(WasiError::ENAMETOOLONG); + pub const ENETDOWN: Self = Error::Wasi(WasiError::ENETDOWN); + pub const ENETRESET: Self = Error::Wasi(WasiError::ENETRESET); + pub const ENETUNREACH: Self = Error::Wasi(WasiError::ENETUNREACH); + pub const ENFILE: Self = Error::Wasi(WasiError::ENFILE); + pub const ENOBUFS: Self = Error::Wasi(WasiError::ENOBUFS); + pub const ENODEV: Self = Error::Wasi(WasiError::ENODEV); + pub const ENOENT: Self = Error::Wasi(WasiError::ENOENT); + pub const ENOEXEC: Self = Error::Wasi(WasiError::ENOEXEC); + pub const ENOLCK: Self = Error::Wasi(WasiError::ENOLCK); + pub const ENOLINK: Self = Error::Wasi(WasiError::ENOLINK); + pub const ENOMEM: Self = Error::Wasi(WasiError::ENOMEM); + pub const ENOMSG: Self = Error::Wasi(WasiError::ENOMSG); + pub const ENOPROTOOPT: Self = Error::Wasi(WasiError::ENOPROTOOPT); + pub const ENOSPC: Self = Error::Wasi(WasiError::ENOSPC); + pub const ENOSYS: Self = Error::Wasi(WasiError::ENOSYS); + pub const ENOTCONN: Self = Error::Wasi(WasiError::ENOTCONN); + pub const ENOTDIR: Self = Error::Wasi(WasiError::ENOTDIR); + pub const ENOTEMPTY: Self = Error::Wasi(WasiError::ENOTEMPTY); + pub const ENOTRECOVERABLE: Self = Error::Wasi(WasiError::ENOTRECOVERABLE); + pub const ENOTSOCK: Self = Error::Wasi(WasiError::ENOTSOCK); + pub const ENOTSUP: Self = Error::Wasi(WasiError::ENOTSUP); + pub const ENOTTY: Self = Error::Wasi(WasiError::ENOTTY); + pub const ENXIO: Self = Error::Wasi(WasiError::ENXIO); + pub const EOVERFLOW: Self = Error::Wasi(WasiError::EOVERFLOW); + pub const EOWNERDEAD: Self = Error::Wasi(WasiError::EOWNERDEAD); + pub const EPERM: Self = Error::Wasi(WasiError::EPERM); + pub const EPIPE: Self = Error::Wasi(WasiError::EPIPE); + pub const EPROTO: Self = Error::Wasi(WasiError::EPROTO); + pub const EPROTONOSUPPORT: Self = Error::Wasi(WasiError::EPROTONOSUPPORT); + pub const EPROTOTYPE: Self = Error::Wasi(WasiError::EPROTOTYPE); + pub const ERANGE: Self = Error::Wasi(WasiError::ERANGE); + pub const EROFS: Self = Error::Wasi(WasiError::EROFS); + pub const ESPIPE: Self = Error::Wasi(WasiError::ESPIPE); + pub const ESRCH: Self = Error::Wasi(WasiError::ESRCH); + pub const ESTALE: Self = Error::Wasi(WasiError::ESTALE); + pub const ETIMEDOUT: Self = Error::Wasi(WasiError::ETIMEDOUT); + pub const ETXTBSY: Self = Error::Wasi(WasiError::ETXTBSY); + pub const EXDEV: Self = Error::Wasi(WasiError::EXDEV); + pub const ENOTCAPABLE: Self = Error::Wasi(WasiError::ENOTCAPABLE); +} + +pub(crate) trait FromRawOsError { + fn from_raw_os_error(code: i32) -> Self; +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +
+use crate::old::snapshot_0::sys::dev_null; +use crate::old::snapshot_0::sys::fdentry_impl::{ + descriptor_as_oshandle, determine_type_and_access_rights, OsHandle, +}; +use crate::old::snapshot_0::{wasi, Error, Result}; +use std::marker::PhantomData; +use std::mem::ManuallyDrop; +use std::ops::{Deref, DerefMut}; +use std::path::PathBuf; +use std::{fs, io}; + +#[derive(Debug)] +pub(crate) enum Descriptor { + OsHandle(OsHandle), + Stdin, + Stdout, + Stderr, +} + +impl Descriptor { + /// Return a reference to the `OsHandle` treating it as an actual file/dir, and + /// allowing operations which require an actual file and not just a stream or + /// socket file descriptor. + pub(crate) fn as_file(&self) -> Result<&OsHandle> { + match self { + Self::OsHandle(file) => Ok(file), + _ => Err(Error::EBADF), + } + } + + /// Like `as_file`, but return a mutable reference. + pub(crate) fn as_file_mut(&mut self) -> Result<&mut OsHandle> { + match self { + Self::OsHandle(file) => Ok(file), + _ => Err(Error::EBADF), + } + } + + /// Return an `OsHandle`, which may be a stream or socket file descriptor. + pub(crate) fn as_os_handle<'descriptor>(&'descriptor self) -> OsHandleRef<'descriptor> { + descriptor_as_oshandle(self) + } +} + +/// An abstraction struct serving as a wrapper for a host `Descriptor` object which requires +/// certain base rights `rights_base` and inheriting rights `rights_inheriting` in order to be +/// accessed correctly. +/// +/// Here, the `descriptor` field stores the host `Descriptor` object (such as a file descriptor, or +/// stdin handle), and accessing it can only be done via the provided `FdEntry::as_descriptor` and +/// `FdEntry::as_descriptor_mut` methods which require a set of base and inheriting rights to be +/// specified, verifying whether the stored `Descriptor` object is valid for the rights specified. +#[derive(Debug)] +pub(crate) struct FdEntry { + pub(crate) file_type: wasi::__wasi_filetype_t, + descriptor: Descriptor, + pub(crate) rights_base: wasi::__wasi_rights_t, + pub(crate) rights_inheriting: wasi::__wasi_rights_t, + pub(crate) preopen_path: Option<PathBuf>, + // TODO: directories +} + +impl FdEntry { + /// Create an FdEntry with *maximal* possible rights from a given `File`. + /// If this is not desired, the rights of the resulting `FdEntry` should + /// be manually restricted. + pub(crate) fn from(file: fs::File) -> Result<Self> { + unsafe { determine_type_and_access_rights(&file) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::OsHandle(OsHandle::from(file)), + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stdin() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stdin()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stdin, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stdout() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stdout()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stdout, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn duplicate_stderr() -> Result<Self> { + unsafe { determine_type_and_access_rights(&io::stderr()) }.map( + |(file_type, rights_base, rights_inheriting)| Self { + file_type, + descriptor: Descriptor::Stderr, + rights_base, + rights_inheriting, + preopen_path: None, + }, + ) + } + + pub(crate) fn null() -> Result<Self> { + Self::from(dev_null()?) + } + + /// Convert this `FdEntry` into a host `Descriptor` object provided the specified + /// `rights_base` and `rights_inheriting` rights are set on this `FdEntry` object. + /// + /// The `FdEntry` can only be converted into a valid `Descriptor` object if + /// the specified set of base rights `rights_base`, and inheriting rights `rights_inheriting` + /// is a subset of rights attached to this `FdEntry`. The check is performed using + /// `FdEntry::validate_rights` method. If the check fails, `Error::ENOTCAPABLE` is returned. + pub(crate) fn as_descriptor( + &self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<&Descriptor> { + self.validate_rights(rights_base, rights_inheriting)?; + Ok(&self.descriptor) + } + + /// Convert this `FdEntry` into a mutable host `Descriptor` object provided the specified + /// `rights_base` and `rights_inheriting` rights are set on this `FdEntry` object. + /// + /// The `FdEntry` can only be converted into a valid `Descriptor` object if + /// the specified set of base rights `rights_base`, and inheriting rights `rights_inheriting` + /// is a subset of rights attached to this `FdEntry`. The check is performed using + /// `FdEntry::validate_rights` method. If the check fails, `Error::ENOTCAPABLE` is returned. + pub(crate) fn as_descriptor_mut( + &mut self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<&mut Descriptor> { + self.validate_rights(rights_base, rights_inheriting)?; + Ok(&mut self.descriptor) + } + + /// Check if this `FdEntry` object satisfies the specified base rights `rights_base`, and + /// inheriting rights `rights_inheriting`; i.e., if rights attached to this `FdEntry` object + /// are a superset. + /// + /// Upon unsuccessful check, `Error::ENOTCAPABLE` is returned. + fn validate_rights( + &self, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + ) -> Result<()> { + if !self.rights_base & rights_base != 0 || !self.rights_inheriting & rights_inheriting != 0 + { + Err(Error::ENOTCAPABLE) + } else { + Ok(()) + } + } + + /// Test whether this descriptor is considered a tty within WASI. + /// Note that since WASI itself lacks an `isatty` syscall and relies + /// on a conservative approximation, we use the same approximation here. + pub(crate) fn isatty(&self) -> bool { + self.file_type == wasi::__WASI_FILETYPE_CHARACTER_DEVICE + && (self.rights_base & (wasi::__WASI_RIGHTS_FD_SEEK | wasi::__WASI_RIGHTS_FD_TELL)) == 0 + } +} + +/// This allows an `OsHandle` to be temporarily borrowed from a +/// `Descriptor`. The `Descriptor` continues to own the resource, +/// and `OsHandleRef`'s lifetime parameter ensures that it doesn't +/// outlive the `Descriptor`. +pub(crate) struct OsHandleRef<'descriptor> { + handle: ManuallyDrop<OsHandle>, + _ref: PhantomData<&'descriptor Descriptor>, +} + +impl<'descriptor> OsHandleRef<'descriptor> { + pub(crate) fn new(handle: ManuallyDrop<OsHandle>) -> Self { + OsHandleRef { + handle, + _ref: PhantomData, + } + } +} + +impl<'descriptor> Deref for OsHandleRef<'descriptor> { + type Target = fs::File; + + fn deref(&self) -> &Self::Target { + &self.handle + } +} + +impl<'descriptor> DerefMut for OsHandleRef<'descriptor> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.handle + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +
+use crate::old::snapshot_0::{Error, Result}; +use std::str; + +/// Creates not-owned WASI path from byte slice. +/// +/// NB WASI spec requires bytes to be valid UTF-8. Otherwise, +/// `__WASI_ERRNO_ILSEQ` error is returned. +pub(crate) fn path_from_slice<'a>(s: &'a [u8]) -> Result<&'a str> { + str::from_utf8(s).map_err(|_| Error::EILSEQ) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +
+//! WASI host types. These are types that contain raw pointers and `usize` +//! values, and so are platform-specific. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] + +use crate::old::snapshot_0::wasi::*; +use crate::old::snapshot_0::{Error, Result}; +use std::{convert::TryInto, io, mem, slice}; +use wig::witx_host_types; + +witx_host_types!("old/snapshot_0" "wasi_unstable"); + +pub(crate) unsafe fn ciovec_to_host(ciovec: &__wasi_ciovec_t) -> io::IoSlice { + let slice = slice::from_raw_parts(ciovec.buf as *const u8, ciovec.buf_len); + io::IoSlice::new(slice) +} + +pub(crate) unsafe fn iovec_to_host_mut(iovec: &mut __wasi_iovec_t) -> io::IoSliceMut { + let slice = slice::from_raw_parts_mut(iovec.buf as *mut u8, iovec.buf_len); + io::IoSliceMut::new(slice) +} + +#[allow(dead_code)] // trouble with sockets +#[derive(Clone, Copy, Debug)] +#[repr(u8)] +pub(crate) enum FileType { + Unknown = __WASI_FILETYPE_UNKNOWN, + BlockDevice = __WASI_FILETYPE_BLOCK_DEVICE, + CharacterDevice = __WASI_FILETYPE_CHARACTER_DEVICE, + Directory = __WASI_FILETYPE_DIRECTORY, + RegularFile = __WASI_FILETYPE_REGULAR_FILE, + SocketDgram = __WASI_FILETYPE_SOCKET_DGRAM, + SocketStream = __WASI_FILETYPE_SOCKET_STREAM, + Symlink = __WASI_FILETYPE_SYMBOLIC_LINK, +} + +impl FileType { + pub(crate) fn to_wasi(&self) -> __wasi_filetype_t { + *self as __wasi_filetype_t + } +} + +#[derive(Debug, Clone)] +pub(crate) struct Dirent { + pub name: String, + pub ftype: FileType, + pub ino: u64, + pub cookie: __wasi_dircookie_t, +} + +impl Dirent { + /// Serialize the directory entry to the format define by `__wasi_fd_readdir`, + /// so that the serialized entries can be concatenated by the implementation. + pub fn to_wasi_raw(&self) -> Result<Vec<u8>> { + let name = self.name.as_bytes(); + let namlen = name.len(); + let dirent_size = mem::size_of::<__wasi_dirent_t>(); + let offset = dirent_size.checked_add(namlen).ok_or(Error::EOVERFLOW)?; + + let mut raw = Vec::<u8>::with_capacity(offset); + raw.resize(offset, 0); + + let sys_dirent = raw.as_mut_ptr() as *mut __wasi_dirent_t; + unsafe { + sys_dirent.write_unaligned(__wasi_dirent_t { + d_namlen: namlen.try_into()?, + d_ino: self.ino, + d_next: self.cookie, + d_type: self.ftype.to_wasi(), + }); + } + + let sys_name = unsafe { sys_dirent.offset(1) as *mut u8 }; + let sys_name = unsafe { slice::from_raw_parts_mut(sys_name, namlen) }; + sys_name.copy_from_slice(&name); + + Ok(raw) + } +} + +#[cfg(test)] +mod test { + use super::*; + #[test] + fn bindgen_test_layout___wasi_prestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).pr_type as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(pr_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).u as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_dir_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_dir_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_dir_t>())).pr_name_len as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_dir_t), + "::", + stringify!(pr_name_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_u_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_u_t>())).dir as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_u_t), + "::", + stringify!(dir) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 + 100 + 101 + 102 + 103 + 104 + 105 + 106 + 107 + 108 + 109 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 120 + 121 + 122 + 123 + 124 + 125 + 126 + 127 + 128 + 129 + 130 + 131 + 132 + 133 + 134 + 135 + 136 + 137 + 138 + 139 + 140 + 141 + 142 + 143 + 144 + 145 + 146 + 147 + 148 + 149 + 150 + 151 + 152 + 153 + 154 + 155 + 156 + 157 + 158 + 159 + 160 + 161 + 162 + 163 + 164 + 165 + 166 + 167 + 168 + 169 + 170 + 171 + 172 + 173 + 174 + 175 + 176 + 177 + 178 + 179 + 180 + 181 + 182 + 183 + 184 + 185 + 186 + 187 + 188 + 189 + 190 + 191 + 192 + 193 + 194 + 195 + 196 + 197 + 198 + 199 + 200 + 201 + 202 + 203 + 204 + 205 + 206 + 207 + 208 + 209 + 210 + 211 + 212 + 213 + 214 + 215 + 216 + 217 + 218 + 219 + 220 + 221 + 222 + 223 + 224 + 225 + 226 + 227 + 228 + 229 + 230 + 231 + 232 + 233 + 234 + 235 + 236 + 237 + 238 + 239 + 240 + 241 + 242 + 243 + 244 + 245 + 246 + 247 + 248 + 249 + 250 + 251 + 252 + 253 + 254 + 255 + 256 + 257 + 258 + 259 + 260 + 261 + 262 + 263 + 264 + 265 + 266 + 267 + 268 + 269 + 270 + 271 + 272 + 273 + 274 + 275 + 276 + 277 + 278 + 279 + 280 + 281 + 282 + 283 + 284 + 285 + 286 + 287 + 288 + 289 + 290 + 291 + 292 + 293 + 294 + 295 + 296 + 297 + 298 + 299 + 300 + 301 + 302 + 303 + 304 + 305 + 306 + 307 + 308 + 309 + 310 + 311 + 312 + 313 + 314 + 315 + 316 + 317 + 318 + 319 + 320 + 321 + 322 + 323 + 324 + 325 + 326 + 327 + 328 + 329 + 330 + 331 + 332 + 333 + 334 + 335 + 336 + 337 + 338 + 339 + 340 + 341 + 342 + 343 + 344 + 345 + 346 + 347 + 348 + 349 + 350 + 351 + 352 + 353 + 354 + 355 + 356 + 357 + 358 + 359 + 360 + 361 + 362 + 363 + 364 + 365 + 366 + 367 + 368 + 369 + 370 + 371 + 372 + 373 + 374 + 375 + 376 + 377 + 378 + 379 + 380 + 381 + 382 + 383 + 384 + 385 + 386 + 387 + 388 + 389 + 390 + 391 + 392 + 393 + 394 + 395 + 396 + 397 + 398 + 399 + 400 + 401 + 402 + 403 + 404 + 405 + 406 + 407 + 408 + 409 + 410 + 411 + 412 + 413 + 414 + 415 + 416 + 417 + 418 + 419 + 420 + 421 + 422 + 423 + 424 + 425 + 426 + 427 + 428 + 429 + 430 + 431 + 432 + 433 + 434 + 435 + 436 + 437 + 438 + 439 + 440 + 441 + 442 + 443 + 444 + 445 + 446 + 447 + 448 + 449 + 450 + 451 + 452 + 453 + 454 + 455 + 456 + 457 + 458 + 459 + 460 + 461 + 462 + 463 + 464 + 465 + 466 + 467 + 468 + 469 + 470 + 471 + 472 + 473 + 474 + 475 + 476 + 477 + 478 + 479 + 480 + 481 + 482 + 483 + 484 + 485 + 486 + 487 + 488 + 489 + 490 + 491 + 492 + 493 + 494 + 495 + 496 + 497 + 498 + 499 + 500 + 501 + 502 + 503 + 504 + 505 + 506 + 507 + 508 + 509 + 510 + 511 + 512 + 513 + 514 + 515 + 516 + 517 + 518 + 519 + 520 + 521 + 522 + 523 + 524 + 525 + 526 + 527 + 528 + 529 + 530 + 531 + 532 + 533 + 534 + 535 + 536 + 537 + 538 + 539 + 540 + 541 + 542 + 543 + 544 + 545 + 546 + 547 + 548 + 549 + 550 + 551 + 552 + 553 + 554 + 555 + 556 + 557 + 558 + 559 + 560 + 561 + 562 + 563 + 564 + 565 + 566 + 567 + 568 + 569 + 570 + 571 + 572 + 573 + 574 + 575 + 576 + 577 + 578 + 579 + 580 + 581 + 582 + 583 + 584 + 585 + 586 + 587 + 588 + 589 + 590 + 591 + 592 + 593 + 594 + 595 + 596 + 597 + 598 + 599 + 600 + 601 + 602 + 603 + 604 + 605 + 606 + 607 + 608 + 609 + 610 + 611 + 612 + 613 + 614 + 615 + 616 + 617 + 618 + 619 + 620 + 621 + 622 + 623 + 624 + 625 + 626 + 627 + 628 + 629 + 630 + 631 + 632 + 633 + 634 + 635 + 636 + 637 + 638 + 639 + 640 + 641 + 642 + 643 + 644 + 645 + 646 + 647 + 648 + 649 + 650 + 651 + 652 + 653 + 654 + 655 + 656 + 657 + 658 + 659 + 660 + 661 + 662 + 663 + 664 + 665 + 666 + 667 + 668 + 669 + 670 + 671 + 672 + 673 + 674 + 675 + 676 + 677 + 678 + 679 + 680 + 681 + 682 + 683 + 684 + 685 + 686 + 687 + 688 + 689 + 690 + 691 + 692 + 693 + 694 + 695 + 696 + 697 + 698 + 699 + 700 + 701 + 702 + 703 + 704 + 705 + 706 + 707 + 708 + 709 + 710 + 711 + 712 + 713 + 714 + 715 + 716 + 717 + 718 + 719 + 720 + 721 + 722 + 723 + 724 + 725 + 726 + 727 + 728 + 729 + 730 + 731 + 732 + 733 + 734 + 735 + 736 + 737 + 738 + 739 + 740 + 741 + 742 + 743 + 744 + 745 + 746 + 747 + 748 + 749 + 750 + 751 + 752 + 753 + 754 + 755 + 756 + 757 + 758 + 759 + 760 + 761 + 762 + 763 + 764 + 765 + 766 + 767 + 768 + 769 + 770 + 771 + 772 + 773 + 774 + 775 + 776 + 777 + 778 + 779 + 780 + 781 + 782 + 783 + 784 + 785 + 786 + 787 + 788 + 789 + 790 + 791 + 792 + 793 + 794 + 795 + 796 + 797 + 798 + 799 + 800 + 801 + 802 + 803 + 804 + 805 + 806 + 807 + 808 + 809 + 810 + 811 + 812 + 813 + 814 + 815 + 816 + 817 + 818 + 819 + 820 + 821 + 822 + 823 + 824 + 825 + 826 + 827 + 828 + 829 + 830 + 831 + 832 + 833 + 834 + 835 + 836 + 837 + 838 + 839 + 840 + 841 + 842 + 843 + 844 + 845 + 846 + 847 + 848 + 849 + 850 + 851 + 852 + 853 + 854 + 855 + 856 + 857 + 858 + 859 + 860 + 861 + 862 + 863 + 864 + 865 + 866 + 867 + 868 + 869 + 870 + 871 + 872 + 873 + 874 + 875 + 876 + 877 + 878 + 879 + 880 + 881 + 882 + 883 + 884 + 885 + 886 + 887 + 888 + 889 + 890 + 891 + 892 + 893 + 894 + 895 + 896 + 897 + 898 + 899 + 900 + 901 + 902 + 903 + 904 + 905 + 906 + 907 + 908 + 909 + 910 + 911 + 912 + 913 + 914 + 915 + 916 + 917 + 918 + 919 + 920 + 921 + 922 + 923 + 924 + 925 + 926 + 927 + 928 + 929 + 930 + 931 + 932 + 933 + 934 + 935 + 936 + 937 + 938 + 939 + 940 + 941 + 942 + 943 + 944 + 945 + 946 + 947 + 948 + 949 + 950 + 951 + 952 + 953 + 954 + 955 + 956 + 957 + 958 + 959 + 960 + 961 + 962 + 963 + 964 + 965 + 966 + 967 + 968 + 969 + 970 + 971 + 972 + 973 + 974 + 975 + 976 + 977 + 978 + 979 + 980 + 981 + 982 + 983 + 984 + 985 + 986 + 987 + 988 + 989 + 990 + 991 + 992 + 993 + 994 + 995 + 996 + 997 + 998 + 999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +
+#![allow(non_camel_case_types)] +use super::fs_helpers::path_get; +use crate::old::snapshot_0::ctx::WasiCtx; +use crate::old::snapshot_0::fdentry::{Descriptor, FdEntry}; +use crate::old::snapshot_0::helpers::*; +use crate::old::snapshot_0::memory::*; +use crate::old::snapshot_0::sys::fdentry_impl::determine_type_rights; +use crate::old::snapshot_0::sys::hostcalls_impl::fs_helpers::path_open_rights; +use crate::old::snapshot_0::sys::{host_impl, hostcalls_impl}; +use crate::old::snapshot_0::{helpers, host, wasi, wasi32, Error, Result}; +use crate::sandboxed_tty_writer::SandboxedTTYWriter; +use filetime::{set_file_handle_times, FileTime}; +use log::trace; +use std::fs::File; +use std::io::{self, Read, Seek, SeekFrom, Write}; +use std::ops::DerefMut; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +pub(crate) unsafe fn fd_close( + wasi_ctx: &mut WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_close(fd={:?})", fd); + + if let Ok(fe) = wasi_ctx.get_fd_entry(fd) { + // can't close preopened files + if fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + } + + wasi_ctx.remove_fd_entry(fd)?; + Ok(()) +} + +pub(crate) unsafe fn fd_datasync( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_datasync(fd={:?})", fd); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_DATASYNC, 0)? + .as_file()?; + + fd.sync_data().map_err(Into::into) +} + +pub(crate) unsafe fn fd_pread( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + offset: wasi::__wasi_filesize_t, + nread: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_pread(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nread + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_READ | wasi::__WASI_RIGHTS_FD_SEEK, 0)? + .as_file()?; + + let iovs = dec_iovec_slice(memory, iovs_ptr, iovs_len)?; + + if offset > i64::max_value() as u64 { + return Err(Error::EIO); + } + let buf_size = iovs.iter().map(|v| v.buf_len).sum(); + let mut buf = vec![0; buf_size]; + let host_nread = hostcalls_impl::fd_pread(fd, &mut buf, offset)?; + let mut buf_offset = 0; + let mut left = host_nread; + for iov in &iovs { + if left == 0 { + break; + } + let vec_len = std::cmp::min(iov.buf_len, left); + std::slice::from_raw_parts_mut(iov.buf as *mut u8, vec_len) + .copy_from_slice(&buf[buf_offset..buf_offset + vec_len]); + buf_offset += vec_len; + left -= vec_len; + } + + trace!(" | *nread={:?}", host_nread); + + enc_usize_byref(memory, nread, host_nread) +} + +pub(crate) unsafe fn fd_pwrite( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + offset: wasi::__wasi_filesize_t, + nwritten: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_pwrite(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nwritten + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor( + wasi::__WASI_RIGHTS_FD_WRITE | wasi::__WASI_RIGHTS_FD_SEEK, + 0, + )? + .as_file()?; + let iovs = dec_ciovec_slice(memory, iovs_ptr, iovs_len)?; + + if offset > i64::max_value() as u64 { + return Err(Error::EIO); + } + let buf_size = iovs.iter().map(|v| v.buf_len).sum(); + let mut buf = Vec::with_capacity(buf_size); + for iov in &iovs { + buf.extend_from_slice(std::slice::from_raw_parts( + iov.buf as *const u8, + iov.buf_len, + )); + } + let host_nwritten = hostcalls_impl::fd_pwrite(fd, &buf, offset)?; + + trace!(" | *nwritten={:?}", host_nwritten); + + enc_usize_byref(memory, nwritten, host_nwritten) +} + +pub(crate) unsafe fn fd_read( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + nread: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_read(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + nread + ); + + let mut iovs = dec_iovec_slice(memory, iovs_ptr, iovs_len)?; + let mut iovs: Vec<io::IoSliceMut> = iovs + .iter_mut() + .map(|vec| host::iovec_to_host_mut(vec)) + .collect(); + + let maybe_host_nread = match wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_READ, 0)? + { + Descriptor::OsHandle(file) => file.read_vectored(&mut iovs), + Descriptor::Stdin => io::stdin().read_vectored(&mut iovs), + _ => return Err(Error::EBADF), + }; + + let host_nread = maybe_host_nread?; + + trace!(" | *nread={:?}", host_nread); + + enc_usize_byref(memory, nread, host_nread) +} + +pub(crate) unsafe fn fd_renumber( + wasi_ctx: &mut WasiCtx, + _mem: &mut [u8], + from: wasi::__wasi_fd_t, + to: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_renumber(from={:?}, to={:?})", from, to); + + if !wasi_ctx.contains_fd_entry(from) { + return Err(Error::EBADF); + } + + // Don't allow renumbering over a pre-opened resource. + // TODO: Eventually, we do want to permit this, once libpreopen in + // userspace is capable of removing entries from its tables as well. + let from_fe = wasi_ctx.get_fd_entry(from)?; + if from_fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + if let Ok(to_fe) = wasi_ctx.get_fd_entry(to) { + if to_fe.preopen_path.is_some() { + return Err(Error::ENOTSUP); + } + } + + let fe = wasi_ctx.remove_fd_entry(from)?; + wasi_ctx.insert_fd_entry_at(to, fe); + + Ok(()) +} + +pub(crate) unsafe fn fd_seek( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filedelta_t, + whence: wasi::__wasi_whence_t, + newoffset: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_seek(fd={:?}, offset={:?}, whence={}, newoffset={:#x?})", + fd, + offset, + wasi::whence_to_str(whence), + newoffset + ); + + let rights = if offset == 0 && whence == wasi::__WASI_WHENCE_CUR { + wasi::__WASI_RIGHTS_FD_TELL + } else { + wasi::__WASI_RIGHTS_FD_SEEK | wasi::__WASI_RIGHTS_FD_TELL + }; + let fd = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(rights, 0)? + .as_file_mut()?; + + let pos = match whence { + wasi::__WASI_WHENCE_CUR => SeekFrom::Current(offset), + wasi::__WASI_WHENCE_END => SeekFrom::End(offset), + wasi::__WASI_WHENCE_SET => SeekFrom::Start(offset as u64), + _ => return Err(Error::EINVAL), + }; + let host_newoffset = fd.seek(pos)?; + + trace!(" | *newoffset={:?}", host_newoffset); + + enc_filesize_byref(memory, newoffset, host_newoffset) +} + +pub(crate) unsafe fn fd_tell( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + newoffset: wasi32::uintptr_t, +) -> Result<()> { + trace!("fd_tell(fd={:?}, newoffset={:#x?})", fd, newoffset); + + let fd = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_TELL, 0)? + .as_file_mut()?; + + let host_offset = fd.seek(SeekFrom::Current(0))?; + + trace!(" | *newoffset={:?}", host_offset); + + enc_filesize_byref(memory, newoffset, host_offset) +} + +pub(crate) unsafe fn fd_fdstat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + fdstat_ptr: wasi32::uintptr_t, // *mut wasi::__wasi_fdstat_t +) -> Result<()> { + trace!("fd_fdstat_get(fd={:?}, fdstat_ptr={:#x?})", fd, fdstat_ptr); + + let mut fdstat = dec_fdstat_byref(memory, fdstat_ptr)?; + let host_fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(0, 0)? + .as_os_handle(); + + let fs_flags = hostcalls_impl::fd_fdstat_get(&host_fd)?; + + let fe = wasi_ctx.get_fd_entry(fd)?; + fdstat.fs_filetype = fe.file_type; + fdstat.fs_rights_base = fe.rights_base; + fdstat.fs_rights_inheriting = fe.rights_inheriting; + fdstat.fs_flags = fs_flags; + + trace!(" | *buf={:?}", fdstat); + + enc_fdstat_byref(memory, fdstat_ptr, fdstat) +} + +pub(crate) unsafe fn fd_fdstat_set_flags( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + fdflags: wasi::__wasi_fdflags_t, +) -> Result<()> { + trace!("fd_fdstat_set_flags(fd={:?}, fdflags={:#x?})", fd, fdflags); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(0, 0)? + .as_os_handle(); + + hostcalls_impl::fd_fdstat_set_flags(&fd, fdflags) +} + +pub(crate) unsafe fn fd_fdstat_set_rights( + wasi_ctx: &mut WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + fs_rights_base: wasi::__wasi_rights_t, + fs_rights_inheriting: wasi::__wasi_rights_t, +) -> Result<()> { + trace!( + "fd_fdstat_set_rights(fd={:?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?})", + fd, + fs_rights_base, + fs_rights_inheriting + ); + + let fe = wasi_ctx.get_fd_entry_mut(fd)?; + if fe.rights_base & fs_rights_base != fs_rights_base + || fe.rights_inheriting & fs_rights_inheriting != fs_rights_inheriting + { + return Err(Error::ENOTCAPABLE); + } + fe.rights_base = fs_rights_base; + fe.rights_inheriting = fs_rights_inheriting; + + Ok(()) +} + +pub(crate) unsafe fn fd_sync( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, +) -> Result<()> { + trace!("fd_sync(fd={:?})", fd); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_SYNC, 0)? + .as_file()?; + fd.sync_all().map_err(Into::into) +} + +pub(crate) unsafe fn fd_write( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + iovs_ptr: wasi32::uintptr_t, + iovs_len: wasi32::size_t, + nwritten: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_write(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + nwritten + ); + + let iovs = dec_ciovec_slice(memory, iovs_ptr, iovs_len)?; + let iovs: Vec<io::IoSlice> = iovs.iter().map(|vec| host::ciovec_to_host(vec)).collect(); + + // perform unbuffered writes + let entry = wasi_ctx.get_fd_entry_mut(fd)?; + let isatty = entry.isatty(); + let desc = entry.as_descriptor_mut(wasi::__WASI_RIGHTS_FD_WRITE, 0)?; + let host_nwritten = match desc { + Descriptor::OsHandle(file) => { + if isatty { + SandboxedTTYWriter::new(file.deref_mut()).write_vectored(&iovs)? + } else { + file.write_vectored(&iovs)? + } + } + Descriptor::Stdin => return Err(Error::EBADF), + Descriptor::Stdout => { + // lock for the duration of the scope + let stdout = io::stdout(); + let mut stdout = stdout.lock(); + let nwritten = if isatty { + SandboxedTTYWriter::new(&mut stdout).write_vectored(&iovs)? + } else { + stdout.write_vectored(&iovs)? + }; + stdout.flush()?; + nwritten + } + // Always sanitize stderr, even if it's not directly connected to a tty, + // because stderr is meant for diagnostics rather than binary output, + // and may be redirected to a file which could end up being displayed + // on a tty later. + Descriptor::Stderr => SandboxedTTYWriter::new(&mut io::stderr()).write_vectored(&iovs)?, + }; + + trace!(" | *nwritten={:?}", host_nwritten); + + enc_usize_byref(memory, nwritten, host_nwritten) +} + +pub(crate) unsafe fn fd_advise( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, + advice: wasi::__wasi_advice_t, +) -> Result<()> { + trace!( + "fd_advise(fd={:?}, offset={}, len={}, advice={:?})", + fd, + offset, + len, + advice + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_ADVISE, 0)? + .as_file()?; + + hostcalls_impl::fd_advise(fd, advice, offset, len) +} + +pub(crate) unsafe fn fd_allocate( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, +) -> Result<()> { + trace!("fd_allocate(fd={:?}, offset={}, len={})", fd, offset, len); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_ALLOCATE, 0)? + .as_file()?; + + let metadata = fd.metadata()?; + + let current_size = metadata.len(); + let wanted_size = offset.checked_add(len).ok_or(Error::E2BIG)?; + // This check will be unnecessary when rust-lang/rust#63326 is fixed + if wanted_size > i64::max_value() as u64 { + return Err(Error::E2BIG); + } + + if wanted_size > current_size { + fd.set_len(wanted_size).map_err(Into::into) + } else { + Ok(()) + } +} + +pub(crate) unsafe fn path_create_directory( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_create_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len, + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(helpers::path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let rights = wasi::__WASI_RIGHTS_PATH_OPEN | wasi::__WASI_RIGHTS_PATH_CREATE_DIRECTORY; + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, rights, 0, 0, path, false)?; + + hostcalls_impl::path_create_directory(resolved) +} + +pub(crate) unsafe fn path_link( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_dirfd: wasi::__wasi_fd_t, + old_flags: wasi::__wasi_lookupflags_t, + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + new_dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_link(old_dirfd={:?}, old_flags={:?}, old_path_ptr={:#x?}, old_path_len={}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_dirfd, + old_flags, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let old_fe = wasi_ctx.get_fd_entry(old_dirfd)?; + let new_fe = wasi_ctx.get_fd_entry(new_dirfd)?; + let resolved_old = path_get( + old_fe, + wasi::__WASI_RIGHTS_PATH_LINK_SOURCE, + 0, + 0, + old_path, + false, + )?; + let resolved_new = path_get( + new_fe, + wasi::__WASI_RIGHTS_PATH_LINK_TARGET, + 0, + 0, + new_path, + false, + )?; + + hostcalls_impl::path_link(resolved_old, resolved_new) +} + +pub(crate) unsafe fn path_open( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + oflags: wasi::__wasi_oflags_t, + fs_rights_base: wasi::__wasi_rights_t, + fs_rights_inheriting: wasi::__wasi_rights_t, + fs_flags: wasi::__wasi_fdflags_t, + fd_out_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_open(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={:?}, oflags={:#x?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?}, fs_flags={:#x?}, fd_out_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + oflags, + fs_rights_base, + fs_rights_inheriting, + fs_flags, + fd_out_ptr + ); + + // pre-encode fd_out_ptr to -1 in case of error in opening a path + enc_fd_byref(memory, fd_out_ptr, wasi::__wasi_fd_t::max_value())?; + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let (needed_base, needed_inheriting) = + path_open_rights(fs_rights_base, fs_rights_inheriting, oflags, fs_flags); + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + needed_base, + needed_inheriting, + dirflags, + path, + oflags & wasi::__WASI_OFLAGS_CREAT != 0, + )?; + + // which open mode do we need? + let read = fs_rights_base & (wasi::__WASI_RIGHTS_FD_READ | wasi::__WASI_RIGHTS_FD_READDIR) != 0; + let write = fs_rights_base + & (wasi::__WASI_RIGHTS_FD_DATASYNC + | wasi::__WASI_RIGHTS_FD_WRITE + | wasi::__WASI_RIGHTS_FD_ALLOCATE + | wasi::__WASI_RIGHTS_FD_FILESTAT_SET_SIZE) + != 0; + + let fd = hostcalls_impl::path_open(resolved, read, write, oflags, fs_flags)?; + + // Determine the type of the new file descriptor and which rights contradict with this type + let (_ty, max_base, max_inheriting) = determine_type_rights(&fd)?; + let mut fe = FdEntry::from(fd)?; + fe.rights_base &= max_base; + fe.rights_inheriting &= max_inheriting; + let guest_fd = wasi_ctx.insert_fd_entry(fe)?; + + trace!(" | *fd={:?}", guest_fd); + + enc_fd_byref(memory, fd_out_ptr, guest_fd) +} + +pub(crate) unsafe fn path_readlink( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + buf_ptr: wasi32::uintptr_t, + buf_len: wasi32::size_t, + buf_used: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_readlink(dirfd={:?}, path_ptr={:#x?}, path_len={:?}, buf_ptr={:#x?}, buf_len={}, buf_used={:#x?})", + dirfd, + path_ptr, + path_len, + buf_ptr, + buf_len, + buf_used, + ); + + enc_usize_byref(memory, buf_used, 0)?; + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(helpers::path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", &path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, wasi::__WASI_RIGHTS_PATH_READLINK, 0, 0, &path, false)?; + + let mut buf = dec_slice_of_mut_u8(memory, buf_ptr, buf_len)?; + + let host_bufused = hostcalls_impl::path_readlink(resolved, &mut buf)?; + + trace!(" | (buf_ptr,*buf_used)={:?}", buf); + trace!(" | *buf_used={:?}", host_bufused); + + enc_usize_byref(memory, buf_used, host_bufused) +} + +pub(crate) unsafe fn path_rename( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_dirfd: wasi::__wasi_fd_t, + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + new_dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_rename(old_dirfd={:?}, old_path_ptr={:#x?}, old_path_len={:?}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={:?})", + old_dirfd, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let old_fe = wasi_ctx.get_fd_entry(old_dirfd)?; + let new_fe = wasi_ctx.get_fd_entry(new_dirfd)?; + let resolved_old = path_get( + old_fe, + wasi::__WASI_RIGHTS_PATH_RENAME_SOURCE, + 0, + 0, + old_path, + true, + )?; + let resolved_new = path_get( + new_fe, + wasi::__WASI_RIGHTS_PATH_RENAME_TARGET, + 0, + 0, + new_path, + true, + )?; + + log::debug!("path_rename resolved_old={:?}", resolved_old); + log::debug!("path_rename resolved_new={:?}", resolved_new); + + hostcalls_impl::path_rename(resolved_old, resolved_new) +} + +pub(crate) unsafe fn fd_filestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + filestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_filestat_get(fd={:?}, filestat_ptr={:#x?})", + fd, + filestat_ptr + ); + + let fd = wasi_ctx.get_fd_entry(fd)?.as_descriptor(0, 0)?.as_file()?; + let host_filestat = hostcalls_impl::fd_filestat_get(fd)?; + + trace!(" | *filestat_ptr={:?}", host_filestat); + + enc_filestat_byref(memory, filestat_ptr, host_filestat) +} + +pub(crate) unsafe fn fd_filestat_set_times( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + trace!( + "fd_filestat_set_times(fd={:?}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + fd, + st_atim, + st_mtim, + fst_flags + ); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_FILESTAT_SET_TIMES, 0)? + .as_file()?; + + fd_filestat_set_times_impl(fd, st_atim, st_mtim, fst_flags) +} + +pub(crate) fn fd_filestat_set_times_impl( + fd: &File, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + let set_atim = fst_flags & wasi::__WASI_FSTFLAGS_ATIM != 0; + let set_atim_now = fst_flags & wasi::__WASI_FSTFLAGS_ATIM_NOW != 0; + let set_mtim = fst_flags & wasi::__WASI_FSTFLAGS_MTIM != 0; + let set_mtim_now = fst_flags & wasi::__WASI_FSTFLAGS_MTIM_NOW != 0; + + if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) { + return Err(Error::EINVAL); + } + let atim = if set_atim { + let time = UNIX_EPOCH + Duration::from_nanos(st_atim); + Some(FileTime::from_system_time(time)) + } else if set_atim_now { + let time = SystemTime::now(); + Some(FileTime::from_system_time(time)) + } else { + None + }; + + let mtim = if set_mtim { + let time = UNIX_EPOCH + Duration::from_nanos(st_mtim); + Some(FileTime::from_system_time(time)) + } else if set_mtim_now { + let time = SystemTime::now(); + Some(FileTime::from_system_time(time)) + } else { + None + }; + set_file_handle_times(fd, atim, mtim).map_err(Into::into) +} + +pub(crate) unsafe fn fd_filestat_set_size( + wasi_ctx: &WasiCtx, + _mem: &mut [u8], + fd: wasi::__wasi_fd_t, + st_size: wasi::__wasi_filesize_t, +) -> Result<()> { + trace!("fd_filestat_set_size(fd={:?}, st_size={})", fd, st_size); + + let fd = wasi_ctx + .get_fd_entry(fd)? + .as_descriptor(wasi::__WASI_RIGHTS_FD_FILESTAT_SET_SIZE, 0)? + .as_file()?; + + // This check will be unnecessary when rust-lang/rust#63326 is fixed + if st_size > i64::max_value() as u64 { + return Err(Error::E2BIG); + } + fd.set_len(st_size).map_err(Into::into) +} + +pub(crate) unsafe fn path_filestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + filestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "path_filestat_get(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, filestat_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + filestat_ptr + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_FILESTAT_GET, + 0, + dirflags, + path, + false, + )?; + let host_filestat = hostcalls_impl::path_filestat_get(resolved, dirflags)?; + + trace!(" | *filestat_ptr={:?}", host_filestat); + + enc_filestat_byref(memory, filestat_ptr, host_filestat) +} + +pub(crate) unsafe fn path_filestat_set_times( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + dirflags: wasi::__wasi_lookupflags_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + trace!( + "path_filestat_set_times(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + st_atim, st_mtim, + fst_flags + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_FILESTAT_SET_TIMES, + 0, + dirflags, + path, + false, + )?; + + hostcalls_impl::path_filestat_set_times(resolved, dirflags, st_atim, st_mtim, fst_flags) +} + +pub(crate) unsafe fn path_symlink( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + old_path_ptr: wasi32::uintptr_t, + old_path_len: wasi32::size_t, + dirfd: wasi::__wasi_fd_t, + new_path_ptr: wasi32::uintptr_t, + new_path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_symlink(old_path_ptr={:#x?}, old_path_len={}, dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_path_ptr, + old_path_len, + dirfd, + new_path_ptr, + new_path_len + ); + + let old_path = dec_slice_of_u8(memory, old_path_ptr, old_path_len).and_then(path_from_slice)?; + let new_path = dec_slice_of_u8(memory, new_path_ptr, new_path_len).and_then(path_from_slice)?; + + trace!(" | (old_path_ptr,old_path_len)='{}'", old_path); + trace!(" | (new_path_ptr,new_path_len)='{}'", new_path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved_new = path_get(fe, wasi::__WASI_RIGHTS_PATH_SYMLINK, 0, 0, new_path, true)?; + + hostcalls_impl::path_symlink(old_path, resolved_new) +} + +pub(crate) unsafe fn path_unlink_file( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_unlink_file(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get(fe, wasi::__WASI_RIGHTS_PATH_UNLINK_FILE, 0, 0, path, false)?; + + hostcalls_impl::path_unlink_file(resolved) +} + +pub(crate) unsafe fn path_remove_directory( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + dirfd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "path_remove_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + + let path = dec_slice_of_u8(memory, path_ptr, path_len).and_then(path_from_slice)?; + + trace!(" | (path_ptr,path_len)='{}'", path); + + let fe = wasi_ctx.get_fd_entry(dirfd)?; + let resolved = path_get( + fe, + wasi::__WASI_RIGHTS_PATH_REMOVE_DIRECTORY, + 0, + 0, + path, + true, + )?; + + log::debug!("path_remove_directory resolved={:?}", resolved); + + hostcalls_impl::path_remove_directory(resolved) +} + +pub(crate) unsafe fn fd_prestat_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + prestat_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_prestat_get(fd={:?}, prestat_ptr={:#x?})", + fd, + prestat_ptr + ); + + // TODO: should we validate any rights here? + let fe = wasi_ctx.get_fd_entry(fd)?; + let po_path = fe.preopen_path.as_ref().ok_or(Error::ENOTSUP)?; + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + return Err(Error::ENOTDIR); + } + + let path = host_impl::path_from_host(po_path.as_os_str())?; + + enc_prestat_byref( + memory, + prestat_ptr, + host::__wasi_prestat_t { + pr_type: wasi::__WASI_PREOPENTYPE_DIR, + u: host::__wasi_prestat_u_t { + dir: host::__wasi_prestat_dir_t { + pr_name_len: path.len(), + }, + }, + }, + ) +} + +pub(crate) unsafe fn fd_prestat_dir_name( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + path_ptr: wasi32::uintptr_t, + path_len: wasi32::size_t, +) -> Result<()> { + trace!( + "fd_prestat_dir_name(fd={:?}, path_ptr={:#x?}, path_len={})", + fd, + path_ptr, + path_len + ); + + // TODO: should we validate any rights here? + let fe = wasi_ctx.get_fd_entry(fd)?; + let po_path = fe.preopen_path.as_ref().ok_or(Error::ENOTSUP)?; + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + return Err(Error::ENOTDIR); + } + + let path = host_impl::path_from_host(po_path.as_os_str())?; + + if path.len() > dec_usize(path_len) { + return Err(Error::ENAMETOOLONG); + } + + trace!(" | (path_ptr,path_len)='{}'", path); + + enc_slice_of_u8(memory, path.as_bytes(), path_ptr) +} + +pub(crate) unsafe fn fd_readdir( + wasi_ctx: &mut WasiCtx, + memory: &mut [u8], + fd: wasi::__wasi_fd_t, + buf: wasi32::uintptr_t, + buf_len: wasi32::size_t, + cookie: wasi::__wasi_dircookie_t, + buf_used: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "fd_readdir(fd={:?}, buf={:#x?}, buf_len={}, cookie={:#x?}, buf_used={:#x?})", + fd, + buf, + buf_len, + cookie, + buf_used, + ); + + enc_usize_byref(memory, buf_used, 0)?; + + let file = wasi_ctx + .get_fd_entry_mut(fd)? + .as_descriptor_mut(wasi::__WASI_RIGHTS_FD_READDIR, 0)? + .as_file_mut()?; + let mut host_buf = dec_slice_of_mut_u8(memory, buf, buf_len)?; + + trace!(" | (buf,buf_len)={:?}", host_buf); + + let iter = hostcalls_impl::fd_readdir(file, cookie)?; + let mut host_bufused = 0; + for dirent in iter { + let dirent_raw = dirent?.to_wasi_raw()?; + let offset = dirent_raw.len(); + if host_buf.len() < offset { + break; + } else { + host_buf[0..offset].copy_from_slice(&dirent_raw); + host_bufused += offset; + host_buf = &mut host_buf[offset..]; + } + } + + trace!(" | *buf_used={:?}", host_bufused); + + enc_usize_byref(memory, buf_used, host_bufused) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +
+#![allow(non_camel_case_types)] +use crate::old::snapshot_0::sys::host_impl; +use crate::old::snapshot_0::sys::hostcalls_impl::fs_helpers::*; +use crate::old::snapshot_0::{error::WasiError, fdentry::FdEntry, wasi, Error, Result}; +use std::fs::File; +use std::path::{Component, Path}; + +#[derive(Debug)] +pub(crate) struct PathGet { + dirfd: File, + path: String, +} + +impl PathGet { + pub(crate) fn dirfd(&self) -> &File { + &self.dirfd + } + + pub(crate) fn path(&self) -> &str { + &self.path + } +} + +/// Normalizes a path to ensure that the target path is located under the directory provided. +/// +/// This is a workaround for not having Capsicum support in the OS. +pub(crate) fn path_get( + fe: &FdEntry, + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + dirflags: wasi::__wasi_lookupflags_t, + path: &str, + needs_final_component: bool, +) -> Result<PathGet> { + const MAX_SYMLINK_EXPANSIONS: usize = 128; + + if path.contains('\0') { + // if contains NUL, return EILSEQ + return Err(Error::EILSEQ); + } + + if fe.file_type != wasi::__WASI_FILETYPE_DIRECTORY { + // if `dirfd` doesn't refer to a directory, return `ENOTDIR`. + return Err(Error::ENOTDIR); + } + + let dirfd = fe + .as_descriptor(rights_base, rights_inheriting)? + .as_file()? + .try_clone()?; + + // Stack of directory file descriptors. Index 0 always corresponds with the directory provided + // to this function. Entering a directory causes a file descriptor to be pushed, while handling + // ".." entries causes an entry to be popped. Index 0 cannot be popped, as this would imply + // escaping the base directory. + let mut dir_stack = vec![dirfd]; + + // Stack of paths left to process. This is initially the `path` argument to this function, but + // any symlinks we encounter are processed by pushing them on the stack. + let mut path_stack = vec![path.to_owned()]; + + // Track the number of symlinks we've expanded, so we can return `ELOOP` after too many. + let mut symlink_expansions = 0; + + // TODO: rewrite this using a custom posix path type, with a component iterator that respects + // trailing slashes. This version does way too much allocation, and is way too fiddly. + loop { + match path_stack.pop() { + Some(cur_path) => { + log::debug!("path_get cur_path = {:?}", cur_path); + + let ends_with_slash = cur_path.ends_with('/'); + let mut components = Path::new(&cur_path).components(); + let head = match components.next() { + None => return Err(Error::ENOENT), + Some(p) => p, + }; + let tail = components.as_path(); + + if tail.components().next().is_some() { + let mut tail = host_impl::path_from_host(tail.as_os_str())?; + if ends_with_slash { + tail.push('/'); + } + path_stack.push(tail); + } + + log::debug!("path_get path_stack = {:?}", path_stack); + + match head { + Component::Prefix(_) | Component::RootDir => { + // path is absolute! + return Err(Error::ENOTCAPABLE); + } + Component::CurDir => { + // "." so skip + } + Component::ParentDir => { + // ".." so pop a dir + let _ = dir_stack.pop().ok_or(Error::ENOTCAPABLE)?; + + // we're not allowed to pop past the original directory + if dir_stack.is_empty() { + return Err(Error::ENOTCAPABLE); + } + } + Component::Normal(head) => { + let mut head = host_impl::path_from_host(head)?; + if ends_with_slash { + // preserve trailing slash + head.push('/'); + } + + if !path_stack.is_empty() || (ends_with_slash && !needs_final_component) { + match openat(dir_stack.last().ok_or(Error::ENOTCAPABLE)?, &head) { + Ok(new_dir) => { + dir_stack.push(new_dir); + } + Err(e) => { + match e.as_wasi_error() { + WasiError::ELOOP + | WasiError::EMLINK + | WasiError::ENOTDIR => + // Check to see if it was a symlink. Linux indicates + // this with ENOTDIR because of the O_DIRECTORY flag. + { + // attempt symlink expansion + let mut link_path = readlinkat( + dir_stack.last().ok_or(Error::ENOTCAPABLE)?, + &head, + )?; + + symlink_expansions += 1; + if symlink_expansions > MAX_SYMLINK_EXPANSIONS { + return Err(Error::ELOOP); + } + + if head.ends_with('/') { + link_path.push('/'); + } + + log::debug!( + "attempted symlink expansion link_path={:?}", + link_path + ); + + path_stack.push(link_path); + } + _ => { + return Err(e); + } + } + } + } + + continue; + } else if ends_with_slash + || (dirflags & wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW) != 0 + { + // if there's a trailing slash, or if `LOOKUP_SYMLINK_FOLLOW` is set, attempt + // symlink expansion + match readlinkat(dir_stack.last().ok_or(Error::ENOTCAPABLE)?, &head) { + Ok(mut link_path) => { + symlink_expansions += 1; + if symlink_expansions > MAX_SYMLINK_EXPANSIONS { + return Err(Error::ELOOP); + } + + if head.ends_with('/') { + link_path.push('/'); + } + + log::debug!( + "attempted symlink expansion link_path={:?}", + link_path + ); + + path_stack.push(link_path); + continue; + } + Err(e) => { + if e.as_wasi_error() != WasiError::EINVAL + && e.as_wasi_error() != WasiError::ENOENT + // this handles the cases when trying to link to + // a destination that already exists, and the target + // path contains a slash + && e.as_wasi_error() != WasiError::ENOTDIR + { + return Err(e); + } + } + } + } + + // not a symlink, so we're done; + return Ok(PathGet { + dirfd: dir_stack.pop().ok_or(Error::ENOTCAPABLE)?, + path: head, + }); + } + } + } + None => { + // no further components to process. means we've hit a case like "." or "a/..", or if the + // input path has trailing slashes and `needs_final_component` is not set + return Ok(PathGet { + dirfd: dir_stack.pop().ok_or(Error::ENOTCAPABLE)?, + path: String::from("."), + }); + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +
+#![allow(non_camel_case_types)] +use crate::old::snapshot_0::ctx::WasiCtx; +use crate::old::snapshot_0::fdentry::Descriptor; +use crate::old::snapshot_0::memory::*; +use crate::old::snapshot_0::sys::hostcalls_impl; +use crate::old::snapshot_0::{wasi, wasi32, Error, Result}; +use log::{error, trace}; +use std::convert::TryFrom; + +pub(crate) fn args_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + argv_ptr: wasi32::uintptr_t, + argv_buf: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "args_get(argv_ptr={:#x?}, argv_buf={:#x?})", + argv_ptr, + argv_buf, + ); + + let mut argv_buf_offset = 0; + let mut argv = vec![]; + + for arg in &wasi_ctx.args { + let arg_bytes = arg.as_bytes_with_nul(); + let arg_ptr = argv_buf + argv_buf_offset; + + enc_slice_of_u8(memory, arg_bytes, arg_ptr)?; + + argv.push(arg_ptr); + + let len = wasi32::uintptr_t::try_from(arg_bytes.len())?; + argv_buf_offset = argv_buf_offset.checked_add(len).ok_or(Error::EOVERFLOW)?; + } + + enc_slice_of_wasi32_uintptr(memory, argv.as_slice(), argv_ptr) +} + +pub(crate) fn args_sizes_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + argc_ptr: wasi32::uintptr_t, + argv_buf_size_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "args_sizes_get(argc_ptr={:#x?}, argv_buf_size_ptr={:#x?})", + argc_ptr, + argv_buf_size_ptr, + ); + + let argc = wasi_ctx.args.len(); + let argv_size = wasi_ctx + .args + .iter() + .map(|arg| arg.as_bytes_with_nul().len()) + .sum(); + + trace!(" | *argc_ptr={:?}", argc); + + enc_usize_byref(memory, argc_ptr, argc)?; + + trace!(" | *argv_buf_size_ptr={:?}", argv_size); + + enc_usize_byref(memory, argv_buf_size_ptr, argv_size) +} + +pub(crate) fn environ_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + environ_ptr: wasi32::uintptr_t, + environ_buf: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "environ_get(environ_ptr={:#x?}, environ_buf={:#x?})", + environ_ptr, + environ_buf, + ); + + let mut environ_buf_offset = 0; + let mut environ = vec![]; + + for pair in &wasi_ctx.env { + let env_bytes = pair.as_bytes_with_nul(); + let env_ptr = environ_buf + environ_buf_offset; + + enc_slice_of_u8(memory, env_bytes, env_ptr)?; + + environ.push(env_ptr); + + let len = wasi32::uintptr_t::try_from(env_bytes.len())?; + environ_buf_offset = environ_buf_offset + .checked_add(len) + .ok_or(Error::EOVERFLOW)?; + } + + enc_slice_of_wasi32_uintptr(memory, environ.as_slice(), environ_ptr) +} + +pub(crate) fn environ_sizes_get( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + environ_count_ptr: wasi32::uintptr_t, + environ_size_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "environ_sizes_get(environ_count_ptr={:#x?}, environ_size_ptr={:#x?})", + environ_count_ptr, + environ_size_ptr, + ); + + let environ_count = wasi_ctx.env.len(); + let environ_size = wasi_ctx + .env + .iter() + .try_fold(0, |acc: u32, pair| { + acc.checked_add(pair.as_bytes_with_nul().len() as u32) + }) + .ok_or(Error::EOVERFLOW)?; + + trace!(" | *environ_count_ptr={:?}", environ_count); + + enc_usize_byref(memory, environ_count_ptr, environ_count)?; + + trace!(" | *environ_size_ptr={:?}", environ_size); + + enc_usize_byref(memory, environ_size_ptr, environ_size as usize) +} + +pub(crate) fn random_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + buf_ptr: wasi32::uintptr_t, + buf_len: wasi32::size_t, +) -> Result<()> { + trace!("random_get(buf_ptr={:#x?}, buf_len={:?})", buf_ptr, buf_len); + + let buf = dec_slice_of_mut_u8(memory, buf_ptr, buf_len)?; + + getrandom::getrandom(buf).map_err(|err| { + error!("getrandom failure: {:?}", err); + Error::EIO + }) +} + +pub(crate) fn clock_res_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + clock_id: wasi::__wasi_clockid_t, + resolution_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "clock_res_get(clock_id={:?}, resolution_ptr={:#x?})", + clock_id, + resolution_ptr, + ); + + let resolution = hostcalls_impl::clock_res_get(clock_id)?; + + trace!(" | *resolution_ptr={:?}", resolution); + + enc_timestamp_byref(memory, resolution_ptr, resolution) +} + +pub(crate) fn clock_time_get( + _wasi_ctx: &WasiCtx, + memory: &mut [u8], + clock_id: wasi::__wasi_clockid_t, + precision: wasi::__wasi_timestamp_t, + time_ptr: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "clock_time_get(clock_id={:?}, precision={:?}, time_ptr={:#x?})", + clock_id, + precision, + time_ptr, + ); + + let time = hostcalls_impl::clock_time_get(clock_id)?; + + trace!(" | *time_ptr={:?}", time); + + enc_timestamp_byref(memory, time_ptr, time) +} + +pub(crate) fn sched_yield(_wasi_ctx: &WasiCtx, _memory: &mut [u8]) -> Result<()> { + trace!("sched_yield()"); + + std::thread::yield_now(); + + Ok(()) +} + +pub(crate) fn poll_oneoff( + wasi_ctx: &WasiCtx, + memory: &mut [u8], + input: wasi32::uintptr_t, + output: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, + nevents: wasi32::uintptr_t, +) -> Result<()> { + trace!( + "poll_oneoff(input={:#x?}, output={:#x?}, nsubscriptions={}, nevents={:#x?})", + input, + output, + nsubscriptions, + nevents, + ); + + if u64::from(nsubscriptions) > wasi::__wasi_filesize_t::max_value() { + return Err(Error::EINVAL); + } + + enc_int_byref(memory, nevents, 0)?; + + let subscriptions = dec_subscriptions(memory, input, nsubscriptions)?; + let mut events = Vec::new(); + + let mut timeout: Option<ClockEventData> = None; + let mut fd_events = Vec::new(); + for subscription in subscriptions { + match subscription.r#type { + wasi::__WASI_EVENTTYPE_CLOCK => { + let clock = unsafe { subscription.u.clock }; + let delay = wasi_clock_to_relative_ns_delay(clock)?; + + log::debug!("poll_oneoff event.u.clock = {:?}", clock); + log::debug!("poll_oneoff delay = {:?}ns", delay); + + let current = ClockEventData { + delay, + userdata: subscription.userdata, + }; + let timeout = timeout.get_or_insert(current); + if current.delay < timeout.delay { + *timeout = current; + } + } + r#type + if r#type == wasi::__WASI_EVENTTYPE_FD_READ + || r#type == wasi::__WASI_EVENTTYPE_FD_WRITE => + { + let wasi_fd = unsafe { subscription.u.fd_readwrite.file_descriptor }; + let rights = if r#type == wasi::__WASI_EVENTTYPE_FD_READ { + wasi::__WASI_RIGHTS_FD_READ + } else { + wasi::__WASI_RIGHTS_FD_WRITE + }; + + match unsafe { + wasi_ctx + .get_fd_entry(wasi_fd) + .and_then(|fe| fe.as_descriptor(rights, 0)) + } { + Ok(descriptor) => fd_events.push(FdEventData { + descriptor, + r#type: subscription.r#type, + userdata: subscription.userdata, + }), + Err(err) => { + let event = wasi::__wasi_event_t { + userdata: subscription.userdata, + r#type, + error: err.as_wasi_error().as_raw_errno(), + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: 0, + }, + }, + }; + events.push(event); + } + }; + } + _ => unreachable!(), + } + } + + log::debug!("poll_oneoff timeout = {:?}", timeout); + log::debug!("poll_oneoff fd_events = {:?}", fd_events); + + hostcalls_impl::poll_oneoff(timeout, fd_events, &mut events)?; + + let events_count = u32::try_from(events.len()).map_err(|_| Error::EOVERFLOW)?; + + enc_events(memory, output, nsubscriptions, events)?; + + trace!(" | *nevents={:?}", events_count); + + enc_int_byref(memory, nevents, events_count) +} + +fn wasi_clock_to_relative_ns_delay(wasi_clock: wasi::__wasi_subscription_clock_t) -> Result<u128> { + use std::time::SystemTime; + + if wasi_clock.flags != wasi::__WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME { + return Ok(u128::from(wasi_clock.timeout)); + } + let now: u128 = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map_err(|_| Error::ENOTCAPABLE)? + .as_nanos(); + let deadline = u128::from(wasi_clock.timeout); + Ok(deadline.saturating_sub(now)) +} + +#[derive(Debug, Copy, Clone)] +pub(crate) struct ClockEventData { + pub(crate) delay: u128, // delay is expressed in nanoseconds + pub(crate) userdata: wasi::__wasi_userdata_t, +} + +#[derive(Debug)] +pub(crate) struct FdEventData<'a> { + pub(crate) descriptor: &'a Descriptor, + pub(crate) r#type: wasi::__wasi_eventtype_t, + pub(crate) userdata: wasi::__wasi_userdata_t, +} + +pub(crate) fn proc_exit(_wasi_ctx: &WasiCtx, _memory: &mut [u8], rval: wasi::__wasi_exitcode_t) { + trace!("proc_exit(rval={:?})", rval); + // TODO: Rather than call std::process::exit here, we should trigger a + // stack unwind similar to a trap. + std::process::exit(rval as i32); +} + +pub(crate) fn proc_raise( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sig: wasi::__wasi_signal_t, +) -> Result<()> { + unimplemented!("proc_raise") +} +
1 +2 +3 +4 +5 +6 +7 +8 +9 +
+mod fs; +mod fs_helpers; +mod misc; +mod sock; + +pub(crate) use self::fs::*; +pub(crate) use self::fs_helpers::PathGet; +pub(crate) use self::misc::*; +pub(crate) use self::sock::*; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +
+use crate::old::snapshot_0::{wasi, wasi32, Result, WasiCtx}; + +pub fn sock_recv( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _ri_data: wasi32::uintptr_t, + _ri_data_len: wasi32::size_t, + _ri_flags: wasi::__wasi_riflags_t, + _ro_datalen: wasi32::uintptr_t, + _ro_flags: wasi32::uintptr_t, +) -> Result<()> { + unimplemented!("sock_recv") +} + +pub fn sock_send( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _si_data: wasi32::uintptr_t, + _si_data_len: wasi32::size_t, + _si_flags: wasi::__wasi_siflags_t, + _so_datalen: wasi32::uintptr_t, +) -> Result<()> { + unimplemented!("sock_send") +} + +pub fn sock_shutdown( + _wasi_ctx: &WasiCtx, + _memory: &mut [u8], + _sock: wasi::__wasi_fd_t, + _how: wasi::__wasi_sdflags_t, +) -> Result<()> { + unimplemented!("sock_shutdown") +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +
+//! Functions to store and load data to and from wasm linear memory, +//! transforming them from and to host data types. +//! +//! Endianness concerns are completely encapsulated in this file, so +//! that users outside this file holding a `wasi::*` value never need +//! to consider what endianness it's in. Inside this file, +//! wasm linear-memory-ordered values are called "raw" values, and +//! are not held for long durations. + +#![allow(unused)] +use crate::old::snapshot_0::{host, wasi, wasi32, Error, Result}; +use num::PrimInt; +use std::convert::TryFrom; +use std::mem::{align_of, size_of}; +use std::{ptr, slice}; + +fn dec_ptr(memory: &[u8], ptr: wasi32::uintptr_t, len: usize) -> Result<*const u8> { + // check for overflow + let checked_len = (ptr as usize).checked_add(len).ok_or(Error::EFAULT)?; + + // translate the pointer + memory + .get(ptr as usize..checked_len) + .ok_or(Error::EFAULT) + .map(|mem| mem.as_ptr()) +} + +fn dec_ptr_mut(memory: &mut [u8], ptr: wasi32::uintptr_t, len: usize) -> Result<*mut u8> { + // check for overflow + let checked_len = (ptr as usize).checked_add(len).ok_or(Error::EFAULT)?; + + // translate the pointer + memory + .get_mut(ptr as usize..checked_len) + .ok_or(Error::EFAULT) + .map(|mem| mem.as_mut_ptr()) +} + +fn dec_ptr_to<'memory, T>(memory: &'memory [u8], ptr: wasi32::uintptr_t) -> Result<&'memory T> { + // check that the ptr is aligned + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + + dec_ptr(memory, ptr, size_of::<T>()).map(|p| unsafe { &*(p as *const T) }) +} + +fn dec_ptr_to_mut<'memory, T>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, +) -> Result<&'memory mut T> { + // check that the ptr is aligned + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + + dec_ptr_mut(memory, ptr, size_of::<T>()).map(|p| unsafe { &mut *(p as *mut T) }) +} + +/// This function does not perform endianness conversions! +fn dec_raw_byref<T>(memory: &[u8], ptr: wasi32::uintptr_t) -> Result<T> { + dec_ptr_to::<T>(memory, ptr).map(|p| unsafe { ptr::read(p) }) +} + +/// This function does not perform endianness conversions! +fn enc_raw_byref<T>(memory: &mut [u8], ptr: wasi32::uintptr_t, t: T) -> Result<()> { + dec_ptr_to_mut::<T>(memory, ptr).map(|p| unsafe { ptr::write(p, t) }) +} + +pub(crate) fn dec_int_byref<T>(memory: &[u8], ptr: wasi32::uintptr_t) -> Result<T> +where + T: PrimInt, +{ + dec_raw_byref::<T>(memory, ptr).map(|i| PrimInt::from_le(i)) +} + +pub(crate) fn enc_int_byref<T>(memory: &mut [u8], ptr: wasi32::uintptr_t, t: T) -> Result<()> +where + T: PrimInt, +{ + enc_raw_byref::<T>(memory, ptr, PrimInt::to_le(t)) +} + +fn check_slice_of<T>(ptr: wasi32::uintptr_t, len: wasi32::size_t) -> Result<(usize, usize)> { + // check alignment, and that length doesn't overflow + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + let len = dec_usize(len); + let len_bytes = if let Some(len) = size_of::<T>().checked_mul(len) { + len + } else { + return Err(Error::EOVERFLOW); + }; + + Ok((len, len_bytes)) +} + +fn dec_raw_slice_of<'memory, T>( + memory: &'memory [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory [T]> { + let (len, len_bytes) = check_slice_of::<T>(ptr, len)?; + let ptr = dec_ptr(memory, ptr, len_bytes)? as *const T; + Ok(unsafe { slice::from_raw_parts(ptr, len) }) +} + +fn dec_raw_slice_of_mut<'memory, T>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory mut [T]> { + let (len, len_bytes) = check_slice_of::<T>(ptr, len)?; + let ptr = dec_ptr_mut(memory, ptr, len_bytes)? as *mut T; + Ok(unsafe { slice::from_raw_parts_mut(ptr, len) }) +} + +fn raw_slice_for_enc<'memory, T>( + memory: &'memory mut [u8], + slice: &[T], + ptr: wasi32::uintptr_t, +) -> Result<&'memory mut [T]> { + // check alignment + if ptr as usize % align_of::<T>() != 0 { + return Err(Error::EINVAL); + } + // check that length doesn't overflow + let len_bytes = if let Some(len) = size_of::<T>().checked_mul(slice.len()) { + len + } else { + return Err(Error::EOVERFLOW); + }; + + // get the pointer into guest memory + let ptr = dec_ptr_mut(memory, ptr, len_bytes)? as *mut T; + + Ok(unsafe { slice::from_raw_parts_mut(ptr, slice.len()) }) +} + +pub(crate) fn dec_slice_of_u8<'memory>( + memory: &'memory [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory [u8]> { + dec_raw_slice_of::<u8>(memory, ptr, len) +} + +pub(crate) fn dec_slice_of_mut_u8<'memory>( + memory: &'memory mut [u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<&'memory mut [u8]> { + dec_raw_slice_of_mut::<u8>(memory, ptr, len) +} + +pub(crate) fn enc_slice_of_u8( + memory: &mut [u8], + slice: &[u8], + ptr: wasi32::uintptr_t, +) -> Result<()> { + let output = raw_slice_for_enc::<u8>(memory, slice, ptr)?; + + output.copy_from_slice(slice); + + Ok(()) +} + +pub(crate) fn enc_slice_of_wasi32_uintptr( + memory: &mut [u8], + slice: &[wasi32::uintptr_t], + ptr: wasi32::uintptr_t, +) -> Result<()> { + let mut output_iter = raw_slice_for_enc::<wasi32::uintptr_t>(memory, slice, ptr)?.into_iter(); + + for p in slice { + *output_iter.next().unwrap() = PrimInt::to_le(*p); + } + + Ok(()) +} + +macro_rules! dec_enc_scalar { + ($ty:ident, $dec_byref:ident, $enc_byref:ident) => { + pub(crate) fn $dec_byref(memory: &mut [u8], ptr: wasi32::uintptr_t) -> Result<wasi::$ty> { + dec_int_byref::<wasi::$ty>(memory, ptr) + } + + pub(crate) fn $enc_byref( + memory: &mut [u8], + ptr: wasi32::uintptr_t, + x: wasi::$ty, + ) -> Result<()> { + enc_int_byref::<wasi::$ty>(memory, ptr, x) + } + }; +} + +pub(crate) fn dec_ciovec_slice( + memory: &[u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<Vec<host::__wasi_ciovec_t>> { + let raw_slice = dec_raw_slice_of::<wasi32::__wasi_ciovec_t>(memory, ptr, len)?; + + raw_slice + .iter() + .map(|raw_iov| { + let len = dec_usize(PrimInt::from_le(raw_iov.buf_len)); + let buf = PrimInt::from_le(raw_iov.buf); + Ok(host::__wasi_ciovec_t { + buf: dec_ptr(memory, buf, len)? as *const u8, + buf_len: len, + }) + }) + .collect() +} + +pub(crate) fn dec_iovec_slice( + memory: &[u8], + ptr: wasi32::uintptr_t, + len: wasi32::size_t, +) -> Result<Vec<host::__wasi_iovec_t>> { + let raw_slice = dec_raw_slice_of::<wasi32::__wasi_iovec_t>(memory, ptr, len)?; + + raw_slice + .iter() + .map(|raw_iov| { + let len = dec_usize(PrimInt::from_le(raw_iov.buf_len)); + let buf = PrimInt::from_le(raw_iov.buf); + Ok(host::__wasi_iovec_t { + buf: dec_ptr(memory, buf, len)? as *mut u8, + buf_len: len, + }) + }) + .collect() +} + +dec_enc_scalar!(__wasi_clockid_t, dec_clockid_byref, enc_clockid_byref); +dec_enc_scalar!(__wasi_errno_t, dec_errno_byref, enc_errno_byref); +dec_enc_scalar!(__wasi_exitcode_t, dec_exitcode_byref, enc_exitcode_byref); +dec_enc_scalar!(__wasi_fd_t, dec_fd_byref, enc_fd_byref); +dec_enc_scalar!(__wasi_fdflags_t, dec_fdflags_byref, enc_fdflags_byref); +dec_enc_scalar!(__wasi_device_t, dev_device_byref, enc_device_byref); +dec_enc_scalar!(__wasi_inode_t, dev_inode_byref, enc_inode_byref); +dec_enc_scalar!(__wasi_linkcount_t, dev_linkcount_byref, enc_linkcount_byref); + +pub(crate) fn dec_filestat_byref( + memory: &mut [u8], + filestat_ptr: wasi32::uintptr_t, +) -> Result<wasi::__wasi_filestat_t> { + let raw = dec_raw_byref::<wasi::__wasi_filestat_t>(memory, filestat_ptr)?; + + Ok(wasi::__wasi_filestat_t { + dev: PrimInt::from_le(raw.dev), + ino: PrimInt::from_le(raw.ino), + filetype: PrimInt::from_le(raw.filetype), + nlink: PrimInt::from_le(raw.nlink), + size: PrimInt::from_le(raw.size), + atim: PrimInt::from_le(raw.atim), + mtim: PrimInt::from_le(raw.mtim), + ctim: PrimInt::from_le(raw.ctim), + }) +} + +pub(crate) fn enc_filestat_byref( + memory: &mut [u8], + filestat_ptr: wasi32::uintptr_t, + filestat: wasi::__wasi_filestat_t, +) -> Result<()> { + let raw = wasi::__wasi_filestat_t { + dev: PrimInt::to_le(filestat.dev), + ino: PrimInt::to_le(filestat.ino), + filetype: PrimInt::to_le(filestat.filetype), + nlink: PrimInt::to_le(filestat.nlink), + size: PrimInt::to_le(filestat.size), + atim: PrimInt::to_le(filestat.atim), + mtim: PrimInt::to_le(filestat.mtim), + ctim: PrimInt::to_le(filestat.ctim), + }; + + enc_raw_byref::<wasi::__wasi_filestat_t>(memory, filestat_ptr, raw) +} + +pub(crate) fn dec_fdstat_byref( + memory: &mut [u8], + fdstat_ptr: wasi32::uintptr_t, +) -> Result<wasi::__wasi_fdstat_t> { + let raw = dec_raw_byref::<wasi::__wasi_fdstat_t>(memory, fdstat_ptr)?; + + Ok(wasi::__wasi_fdstat_t { + fs_filetype: PrimInt::from_le(raw.fs_filetype), + fs_flags: PrimInt::from_le(raw.fs_flags), + fs_rights_base: PrimInt::from_le(raw.fs_rights_base), + fs_rights_inheriting: PrimInt::from_le(raw.fs_rights_inheriting), + }) +} + +pub(crate) fn enc_fdstat_byref( + memory: &mut [u8], + fdstat_ptr: wasi32::uintptr_t, + fdstat: wasi::__wasi_fdstat_t, +) -> Result<()> { + let raw = wasi::__wasi_fdstat_t { + fs_filetype: PrimInt::to_le(fdstat.fs_filetype), + fs_flags: PrimInt::to_le(fdstat.fs_flags), + fs_rights_base: PrimInt::to_le(fdstat.fs_rights_base), + fs_rights_inheriting: PrimInt::to_le(fdstat.fs_rights_inheriting), + }; + + enc_raw_byref::<wasi::__wasi_fdstat_t>(memory, fdstat_ptr, raw) +} + +dec_enc_scalar!(__wasi_filedelta_t, dec_filedelta_byref, enc_filedelta_byref); +dec_enc_scalar!(__wasi_filesize_t, dec_filesize_byref, enc_filesize_byref); +dec_enc_scalar!(__wasi_filetype_t, dec_filetype_byref, enc_filetype_byref); + +dec_enc_scalar!( + __wasi_lookupflags_t, + dec_lookupflags_byref, + enc_lookupflags_byref +); + +dec_enc_scalar!(__wasi_oflags_t, dec_oflags_byref, enc_oflags_byref); + +pub(crate) fn dec_prestat_byref( + memory: &mut [u8], + prestat_ptr: wasi32::uintptr_t, +) -> Result<host::__wasi_prestat_t> { + let raw = dec_raw_byref::<wasi32::__wasi_prestat_t>(memory, prestat_ptr)?; + + match PrimInt::from_le(raw.pr_type) { + wasi::__WASI_PREOPENTYPE_DIR => Ok(host::__wasi_prestat_t { + pr_type: wasi::__WASI_PREOPENTYPE_DIR, + u: host::__wasi_prestat_u_t { + dir: host::__wasi_prestat_dir_t { + pr_name_len: dec_usize(PrimInt::from_le(unsafe { raw.u.dir.pr_name_len })), + }, + }, + }), + _ => Err(Error::EINVAL), + } +} + +pub(crate) fn enc_prestat_byref( + memory: &mut [u8], + prestat_ptr: wasi32::uintptr_t, + prestat: host::__wasi_prestat_t, +) -> Result<()> { + let raw = match prestat.pr_type { + wasi::__WASI_PREOPENTYPE_DIR => Ok(wasi32::__wasi_prestat_t { + pr_type: PrimInt::to_le(wasi::__WASI_PREOPENTYPE_DIR), + u: wasi32::__wasi_prestat_u_t { + dir: wasi32::__wasi_prestat_dir_t { + pr_name_len: enc_usize(unsafe { prestat.u.dir.pr_name_len }), + }, + }, + }), + _ => Err(Error::EINVAL), + }?; + + enc_raw_byref::<wasi32::__wasi_prestat_t>(memory, prestat_ptr, raw) +} + +dec_enc_scalar!(__wasi_rights_t, dec_rights_byref, enc_rights_byref); +dec_enc_scalar!(__wasi_timestamp_t, dec_timestamp_byref, enc_timestamp_byref); + +pub(crate) fn dec_usize(size: wasi32::size_t) -> usize { + usize::try_from(size).unwrap() +} + +pub(crate) fn enc_usize(size: usize) -> wasi32::size_t { + wasi32::size_t::try_from(size).unwrap() +} + +pub(crate) fn enc_usize_byref( + memory: &mut [u8], + usize_ptr: wasi32::uintptr_t, + host_usize: usize, +) -> Result<()> { + enc_int_byref::<wasi32::size_t>(memory, usize_ptr, enc_usize(host_usize)) +} + +dec_enc_scalar!(__wasi_whence_t, dec_whence_byref, enc_whence_byref); + +dec_enc_scalar!( + __wasi_subclockflags_t, + dec_subclockflags_byref, + enc_subclockflags_byref +); + +dec_enc_scalar!( + __wasi_eventrwflags_t, + dec_eventrwflags_byref, + enc_eventrwflags_byref +); + +dec_enc_scalar!(__wasi_eventtype_t, dec_eventtype_byref, enc_eventtype_byref); +dec_enc_scalar!(__wasi_userdata_t, dec_userdata_byref, enc_userdata_byref); + +pub(crate) fn dec_subscriptions( + memory: &mut [u8], + input: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, +) -> Result<Vec<wasi::__wasi_subscription_t>> { + let raw_input_slice = + dec_raw_slice_of::<wasi::__wasi_subscription_t>(memory, input, nsubscriptions)?; + + raw_input_slice + .into_iter() + .map(|raw_subscription| { + let userdata = PrimInt::from_le(raw_subscription.userdata); + let r#type = PrimInt::from_le(raw_subscription.r#type); + let raw_u = raw_subscription.u; + let u = match r#type { + wasi::__WASI_EVENTTYPE_CLOCK => wasi::__wasi_subscription_u_t { + clock: unsafe { + wasi::__wasi_subscription_clock_t { + identifier: PrimInt::from_le(raw_u.clock.identifier), + id: PrimInt::from_le(raw_u.clock.id), + timeout: PrimInt::from_le(raw_u.clock.timeout), + precision: PrimInt::from_le(raw_u.clock.precision), + flags: PrimInt::from_le(raw_u.clock.flags), + } + }, + }, + wasi::__WASI_EVENTTYPE_FD_READ | wasi::__WASI_EVENTTYPE_FD_WRITE => { + wasi::__wasi_subscription_u_t { + fd_readwrite: wasi::__wasi_subscription_fd_readwrite_t { + file_descriptor: PrimInt::from_le(unsafe { + raw_u.fd_readwrite.file_descriptor + }), + }, + } + } + _ => return Err(Error::EINVAL), + }; + Ok(wasi::__wasi_subscription_t { + userdata, + r#type, + u, + }) + }) + .collect::<Result<Vec<_>>>() +} + +pub(crate) fn enc_events( + memory: &mut [u8], + output: wasi32::uintptr_t, + nsubscriptions: wasi32::size_t, + events: Vec<wasi::__wasi_event_t>, +) -> Result<()> { + let mut raw_output_iter = + dec_raw_slice_of_mut::<wasi::__wasi_event_t>(memory, output, nsubscriptions)?.into_iter(); + + for event in events.iter() { + *raw_output_iter + .next() + .expect("the number of events cannot exceed the number of subscriptions") = { + let fd_readwrite = unsafe { event.u.fd_readwrite }; + wasi::__wasi_event_t { + userdata: PrimInt::to_le(event.userdata), + r#type: PrimInt::to_le(event.r#type), + error: PrimInt::to_le(event.error), + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: PrimInt::to_le(fd_readwrite.nbytes), + flags: PrimInt::to_le(fd_readwrite.flags), + }, + }, + } + }; + } + + Ok(()) +} + +dec_enc_scalar!(__wasi_advice_t, dec_advice_byref, enc_advice_byref); +dec_enc_scalar!(__wasi_fstflags_t, dec_fstflags_byref, enc_fstflags_byref); +dec_enc_scalar!(__wasi_dircookie_t, dec_dircookie_byref, enc_dircookie_byref); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +
+mod ctx; +mod error; +mod fdentry; +mod helpers; +mod host; +mod hostcalls_impl; +mod memory; +mod sys; +pub mod wasi; +pub mod wasi32; + +pub mod hostcalls { + wig::define_hostcalls!("old/snapshot_0" "wasi_unstable"); +} + +pub use ctx::{WasiCtx, WasiCtxBuilder}; + +pub type Error = error::Error; +pub type Result<T> = std::result::Result<T, Error>; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +
+use cfg_if::cfg_if; + +cfg_if! { + if #[cfg(unix)] { + mod unix; + pub(crate) use self::unix::*; + } else if #[cfg(windows)] { + mod windows; + pub(crate) use self::windows::*; + } else { + compile_error!("wasi-common doesn't compile for this platform yet"); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +
+use crate::old::snapshot_0::fdentry::{Descriptor, OsHandleRef}; +use crate::old::snapshot_0::{sys::unix::sys_impl, wasi, Error, Result}; +use std::fs::File; +use std::io; +use std::mem::ManuallyDrop; +use std::os::unix::prelude::{AsRawFd, FileTypeExt, FromRawFd, RawFd}; + +pub(crate) use sys_impl::oshandle::*; + +impl AsRawFd for Descriptor { + fn as_raw_fd(&self) -> RawFd { + match self { + Self::OsHandle(file) => file.as_raw_fd(), + Self::Stdin => io::stdin().as_raw_fd(), + Self::Stdout => io::stdout().as_raw_fd(), + Self::Stderr => io::stderr().as_raw_fd(), + } + } +} + +pub(crate) fn descriptor_as_oshandle<'lifetime>( + desc: &'lifetime Descriptor, +) -> OsHandleRef<'lifetime> { + OsHandleRef::new(ManuallyDrop::new(OsHandle::from(unsafe { + File::from_raw_fd(desc.as_raw_fd()) + }))) +} + +/// This function is unsafe because it operates on a raw file descriptor. +pub(crate) unsafe fn determine_type_and_access_rights<Fd: AsRawFd>( + fd: &Fd, +) -> Result<( + wasi::__wasi_filetype_t, + wasi::__wasi_rights_t, + wasi::__wasi_rights_t, +)> { + let (file_type, mut rights_base, rights_inheriting) = determine_type_rights(fd)?; + + use yanix::{fcntl, file::OFlag}; + let flags = fcntl::get_status_flags(fd.as_raw_fd())?; + let accmode = flags & OFlag::ACCMODE; + if accmode == OFlag::RDONLY { + rights_base &= !wasi::__WASI_RIGHTS_FD_WRITE; + } else if accmode == OFlag::WRONLY { + rights_base &= !wasi::__WASI_RIGHTS_FD_READ; + } + + Ok((file_type, rights_base, rights_inheriting)) +} + +/// This function is unsafe because it operates on a raw file descriptor. +pub(crate) unsafe fn determine_type_rights<Fd: AsRawFd>( + fd: &Fd, +) -> Result<( + wasi::__wasi_filetype_t, + wasi::__wasi_rights_t, + wasi::__wasi_rights_t, +)> { + let (file_type, rights_base, rights_inheriting) = { + // we just make a `File` here for convenience; we don't want it to close when it drops + let file = std::mem::ManuallyDrop::new(std::fs::File::from_raw_fd(fd.as_raw_fd())); + let ft = file.metadata()?.file_type(); + if ft.is_block_device() { + log::debug!("Host fd {:?} is a block device", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_BLOCK_DEVICE, + wasi::RIGHTS_BLOCK_DEVICE_BASE, + wasi::RIGHTS_BLOCK_DEVICE_INHERITING, + ) + } else if ft.is_char_device() { + log::debug!("Host fd {:?} is a char device", fd.as_raw_fd()); + use yanix::file::isatty; + if isatty(fd.as_raw_fd())? { + ( + wasi::__WASI_FILETYPE_CHARACTER_DEVICE, + wasi::RIGHTS_TTY_BASE, + wasi::RIGHTS_TTY_BASE, + ) + } else { + ( + wasi::__WASI_FILETYPE_CHARACTER_DEVICE, + wasi::RIGHTS_CHARACTER_DEVICE_BASE, + wasi::RIGHTS_CHARACTER_DEVICE_INHERITING, + ) + } + } else if ft.is_dir() { + log::debug!("Host fd {:?} is a directory", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_DIRECTORY, + wasi::RIGHTS_DIRECTORY_BASE, + wasi::RIGHTS_DIRECTORY_INHERITING, + ) + } else if ft.is_file() { + log::debug!("Host fd {:?} is a file", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_REGULAR_FILE, + wasi::RIGHTS_REGULAR_FILE_BASE, + wasi::RIGHTS_REGULAR_FILE_INHERITING, + ) + } else if ft.is_socket() { + log::debug!("Host fd {:?} is a socket", fd.as_raw_fd()); + use yanix::socket::{get_socket_type, SockType}; + match get_socket_type(fd.as_raw_fd())? { + SockType::Datagram => ( + wasi::__WASI_FILETYPE_SOCKET_DGRAM, + wasi::RIGHTS_SOCKET_BASE, + wasi::RIGHTS_SOCKET_INHERITING, + ), + SockType::Stream => ( + wasi::__WASI_FILETYPE_SOCKET_STREAM, + wasi::RIGHTS_SOCKET_BASE, + wasi::RIGHTS_SOCKET_INHERITING, + ), + _ => return Err(Error::EINVAL), + } + } else if ft.is_fifo() { + log::debug!("Host fd {:?} is a fifo", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_UNKNOWN, + wasi::RIGHTS_REGULAR_FILE_BASE, + wasi::RIGHTS_REGULAR_FILE_INHERITING, + ) + } else { + log::debug!("Host fd {:?} is unknown", fd.as_raw_fd()); + return Err(Error::EINVAL); + } + }; + + Ok((file_type, rights_base, rights_inheriting)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +
+//! This internal module consists of helper types and functions for dealing +//! with setting the file times (mainly in `path_filestat_set_times` syscall for now). +//! +//! The vast majority of the code contained within and in platform-specific implementations +//! (`super::linux::filetime` and `super::bsd::filetime`) is based on the [filetime] crate. +//! Kudos @alexcrichton! +//! +//! [filetime]: https://github.com/alexcrichton/filetime +use crate::old::snapshot_0::Result; +use std::convert::TryInto; + +pub(crate) use super::sys_impl::filetime::*; + +cfg_if::cfg_if! { + if #[cfg(not(target_os = "emscripten"))] { + fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { + Ok( + libc::timespec { + tv_sec: ft.seconds(), + tv_nsec: ft.nanoseconds().try_into()?, + } + ) + } + } else { + fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { + Ok( + libc::timespec { + tv_sec: ft.seconds().try_into()?, + tv_nsec: ft.nanoseconds().try_into()?, + } + ) + } + } +} + +/// A wrapper `enum` around `filetime::FileTime` struct, but unlike the original, this +/// type allows the possibility of specifying `FileTime::Now` as a valid enumeration which, +/// in turn, if `utimensat` is available on the host, will use a special const setting +/// `UTIME_NOW`. +#[derive(Debug, Copy, Clone)] +pub(crate) enum FileTime { + Now, + Omit, + FileTime(filetime::FileTime), +} + +/// Converts `FileTime` to `libc::timespec`. If `FileTime::Now` variant is specified, this +/// resolves to `UTIME_NOW` special const, `FileTime::Omit` variant resolves to `UTIME_OMIT`, and +/// `FileTime::FileTime(ft)` where `ft := filetime::FileTime` uses [filetime] crate's original +/// implementation which can be found here: [filetime::unix::to_timespec]. +/// +/// [filetime]: https://github.com/alexcrichton/filetime +/// [filetime::unix::to_timespec]: https://github.com/alexcrichton/filetime/blob/master/src/unix/mod.rs#L30 +pub(crate) fn to_timespec(ft: &FileTime) -> Result<libc::timespec> { + let ts = match ft { + FileTime::Now => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_NOW, + }, + FileTime::Omit => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_OMIT, + }, + FileTime::FileTime(ft) => filetime_to_timespec(ft)?, + }; + Ok(ts) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +
+//! WASI host types specific to *nix host. +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] +use crate::old::snapshot_0::host::FileType; +use crate::old::snapshot_0::{ + error::FromRawOsError, helpers, sys::unix::sys_impl, wasi, Error, Result, +}; +use std::ffi::OsStr; +use std::os::unix::prelude::OsStrExt; +use yanix::{ + file::{OFlag, SFlag}, + Errno, +}; + +pub(crate) use sys_impl::host_impl::*; + +impl FromRawOsError for Error { + fn from_raw_os_error(code: i32) -> Self { + Self::from(Errno::from_i32(code)) + } +} + +impl From<Errno> for Error { + fn from(errno: Errno) -> Self { + match errno { + Errno::EPERM => Self::EPERM, + Errno::ENOENT => Self::ENOENT, + Errno::ESRCH => Self::ESRCH, + Errno::EINTR => Self::EINTR, + Errno::EIO => Self::EIO, + Errno::ENXIO => Self::ENXIO, + Errno::E2BIG => Self::E2BIG, + Errno::ENOEXEC => Self::ENOEXEC, + Errno::EBADF => Self::EBADF, + Errno::ECHILD => Self::ECHILD, + Errno::EAGAIN => Self::EAGAIN, + Errno::ENOMEM => Self::ENOMEM, + Errno::EACCES => Self::EACCES, + Errno::EFAULT => Self::EFAULT, + Errno::EBUSY => Self::EBUSY, + Errno::EEXIST => Self::EEXIST, + Errno::EXDEV => Self::EXDEV, + Errno::ENODEV => Self::ENODEV, + Errno::ENOTDIR => Self::ENOTDIR, + Errno::EISDIR => Self::EISDIR, + Errno::EINVAL => Self::EINVAL, + Errno::ENFILE => Self::ENFILE, + Errno::EMFILE => Self::EMFILE, + Errno::ENOTTY => Self::ENOTTY, + Errno::ETXTBSY => Self::ETXTBSY, + Errno::EFBIG => Self::EFBIG, + Errno::ENOSPC => Self::ENOSPC, + Errno::ESPIPE => Self::ESPIPE, + Errno::EROFS => Self::EROFS, + Errno::EMLINK => Self::EMLINK, + Errno::EPIPE => Self::EPIPE, + Errno::EDOM => Self::EDOM, + Errno::ERANGE => Self::ERANGE, + Errno::EDEADLK => Self::EDEADLK, + Errno::ENAMETOOLONG => Self::ENAMETOOLONG, + Errno::ENOLCK => Self::ENOLCK, + Errno::ENOSYS => Self::ENOSYS, + Errno::ENOTEMPTY => Self::ENOTEMPTY, + Errno::ELOOP => Self::ELOOP, + Errno::ENOMSG => Self::ENOMSG, + Errno::EIDRM => Self::EIDRM, + Errno::ENOLINK => Self::ENOLINK, + Errno::EPROTO => Self::EPROTO, + Errno::EMULTIHOP => Self::EMULTIHOP, + Errno::EBADMSG => Self::EBADMSG, + Errno::EOVERFLOW => Self::EOVERFLOW, + Errno::EILSEQ => Self::EILSEQ, + Errno::ENOTSOCK => Self::ENOTSOCK, + Errno::EDESTADDRREQ => Self::EDESTADDRREQ, + Errno::EMSGSIZE => Self::EMSGSIZE, + Errno::EPROTOTYPE => Self::EPROTOTYPE, + Errno::ENOPROTOOPT => Self::ENOPROTOOPT, + Errno::EPROTONOSUPPORT => Self::EPROTONOSUPPORT, + Errno::EAFNOSUPPORT => Self::EAFNOSUPPORT, + Errno::EADDRINUSE => Self::EADDRINUSE, + Errno::EADDRNOTAVAIL => Self::EADDRNOTAVAIL, + Errno::ENETDOWN => Self::ENETDOWN, + Errno::ENETUNREACH => Self::ENETUNREACH, + Errno::ENETRESET => Self::ENETRESET, + Errno::ECONNABORTED => Self::ECONNABORTED, + Errno::ECONNRESET => Self::ECONNRESET, + Errno::ENOBUFS => Self::ENOBUFS, + Errno::EISCONN => Self::EISCONN, + Errno::ENOTCONN => Self::ENOTCONN, + Errno::ETIMEDOUT => Self::ETIMEDOUT, + Errno::ECONNREFUSED => Self::ECONNREFUSED, + Errno::EHOSTUNREACH => Self::EHOSTUNREACH, + Errno::EALREADY => Self::EALREADY, + Errno::EINPROGRESS => Self::EINPROGRESS, + Errno::ESTALE => Self::ESTALE, + Errno::EDQUOT => Self::EDQUOT, + Errno::ECANCELED => Self::ECANCELED, + Errno::EOWNERDEAD => Self::EOWNERDEAD, + Errno::ENOTRECOVERABLE => Self::ENOTRECOVERABLE, + } + } +} + +pub(crate) fn nix_from_fdflags(fdflags: wasi::__wasi_fdflags_t) -> OFlag { + let mut nix_flags = OFlag::empty(); + if fdflags & wasi::__WASI_FDFLAGS_APPEND != 0 { + nix_flags.insert(OFlag::APPEND); + } + if fdflags & wasi::__WASI_FDFLAGS_DSYNC != 0 { + nix_flags.insert(OFlag::DSYNC); + } + if fdflags & wasi::__WASI_FDFLAGS_NONBLOCK != 0 { + nix_flags.insert(OFlag::NONBLOCK); + } + if fdflags & wasi::__WASI_FDFLAGS_RSYNC != 0 { + nix_flags.insert(O_RSYNC); + } + if fdflags & wasi::__WASI_FDFLAGS_SYNC != 0 { + nix_flags.insert(OFlag::SYNC); + } + nix_flags +} + +pub(crate) fn fdflags_from_nix(oflags: OFlag) -> wasi::__wasi_fdflags_t { + let mut fdflags = 0; + if oflags.contains(OFlag::APPEND) { + fdflags |= wasi::__WASI_FDFLAGS_APPEND; + } + if oflags.contains(OFlag::DSYNC) { + fdflags |= wasi::__WASI_FDFLAGS_DSYNC; + } + if oflags.contains(OFlag::NONBLOCK) { + fdflags |= wasi::__WASI_FDFLAGS_NONBLOCK; + } + if oflags.contains(O_RSYNC) { + fdflags |= wasi::__WASI_FDFLAGS_RSYNC; + } + if oflags.contains(OFlag::SYNC) { + fdflags |= wasi::__WASI_FDFLAGS_SYNC; + } + fdflags +} + +pub(crate) fn nix_from_oflags(oflags: wasi::__wasi_oflags_t) -> OFlag { + let mut nix_flags = OFlag::empty(); + if oflags & wasi::__WASI_OFLAGS_CREAT != 0 { + nix_flags.insert(OFlag::CREAT); + } + if oflags & wasi::__WASI_OFLAGS_DIRECTORY != 0 { + nix_flags.insert(OFlag::DIRECTORY); + } + if oflags & wasi::__WASI_OFLAGS_EXCL != 0 { + nix_flags.insert(OFlag::EXCL); + } + if oflags & wasi::__WASI_OFLAGS_TRUNC != 0 { + nix_flags.insert(OFlag::TRUNC); + } + nix_flags +} + +pub(crate) fn filetype_from_nix(sflags: SFlag) -> FileType { + if sflags.contains(SFlag::IFCHR) { + FileType::CharacterDevice + } else if sflags.contains(SFlag::IFBLK) { + FileType::BlockDevice + } else if sflags.contains(SFlag::IFSOCK) { + FileType::SocketStream + } else if sflags.contains(SFlag::IFDIR) { + FileType::Directory + } else if sflags.contains(SFlag::IFREG) { + FileType::RegularFile + } else if sflags.contains(SFlag::IFLNK) { + FileType::Symlink + } else { + FileType::Unknown + } +} + +pub(crate) fn filestat_from_nix(filestat: libc::stat) -> Result<wasi::__wasi_filestat_t> { + use std::convert::TryInto; + + fn filestat_to_timestamp(secs: u64, nsecs: u64) -> Result<wasi::__wasi_timestamp_t> { + secs.checked_mul(1_000_000_000) + .and_then(|sec_nsec| sec_nsec.checked_add(nsecs)) + .ok_or(Error::EOVERFLOW) + } + + let filetype = SFlag::from_bits_truncate(filestat.st_mode); + let dev = stdev_from_nix(filestat.st_dev)?; + let ino = stino_from_nix(filestat.st_ino)?; + let atim = filestat_to_timestamp( + filestat.st_atime.try_into()?, + filestat.st_atime_nsec.try_into()?, + )?; + let ctim = filestat_to_timestamp( + filestat.st_ctime.try_into()?, + filestat.st_ctime_nsec.try_into()?, + )?; + let mtim = filestat_to_timestamp( + filestat.st_mtime.try_into()?, + filestat.st_mtime_nsec.try_into()?, + )?; + + Ok(wasi::__wasi_filestat_t { + dev, + ino, + nlink: stnlink_from_nix(filestat.st_nlink)?, + size: filestat.st_size as wasi::__wasi_filesize_t, + atim, + ctim, + mtim, + filetype: filetype_from_nix(filetype).to_wasi(), + }) +} + +pub(crate) fn dirent_filetype_from_host( + host_entry: &libc::dirent, +) -> Result<wasi::__wasi_filetype_t> { + match host_entry.d_type { + libc::DT_FIFO => Ok(wasi::__WASI_FILETYPE_UNKNOWN), + libc::DT_CHR => Ok(wasi::__WASI_FILETYPE_CHARACTER_DEVICE), + libc::DT_DIR => Ok(wasi::__WASI_FILETYPE_DIRECTORY), + libc::DT_BLK => Ok(wasi::__WASI_FILETYPE_BLOCK_DEVICE), + libc::DT_REG => Ok(wasi::__WASI_FILETYPE_REGULAR_FILE), + libc::DT_LNK => Ok(wasi::__WASI_FILETYPE_SYMBOLIC_LINK), + libc::DT_SOCK => { + // TODO how to discriminate between STREAM and DGRAM? + // Perhaps, we should create a more general WASI filetype + // such as __WASI_FILETYPE_SOCKET, and then it would be + // up to the client to check whether it's actually + // STREAM or DGRAM? + Ok(wasi::__WASI_FILETYPE_UNKNOWN) + } + libc::DT_UNKNOWN => Ok(wasi::__WASI_FILETYPE_UNKNOWN), + _ => Err(Error::EINVAL), + } +} + +/// Creates owned WASI path from OS string. +/// +/// NB WASI spec requires OS string to be valid UTF-8. Otherwise, +/// `__WASI_ERRNO_ILSEQ` error is returned. +pub(crate) fn path_from_host<S: AsRef<OsStr>>(s: S) -> Result<String> { + helpers::path_from_slice(s.as_ref().as_bytes()).map(String::from) +} + +impl From<yanix::dir::FileType> for FileType { + fn from(ft: yanix::dir::FileType) -> Self { + use yanix::dir::FileType::*; + match ft { + RegularFile => Self::RegularFile, + Symlink => Self::Symlink, + Directory => Self::Directory, + BlockDevice => Self::BlockDevice, + CharacterDevice => Self::CharacterDevice, + /* Unknown | Socket | Fifo */ _ => Self::Unknown, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::old::snapshot_0::host::Dirent; +use crate::old::snapshot_0::hostcalls_impl::PathGet; +use crate::old::snapshot_0::sys::{fdentry_impl::OsHandle, host_impl, unix::sys_impl}; +use crate::old::snapshot_0::{wasi, Error, Result}; +use std::convert::TryInto; +use std::fs::File; +use std::os::unix::fs::FileExt; +use std::os::unix::prelude::{AsRawFd, FromRawFd}; + +pub(crate) use sys_impl::hostcalls_impl::*; + +pub(crate) fn fd_pread( + file: &File, + buf: &mut [u8], + offset: wasi::__wasi_filesize_t, +) -> Result<usize> { + file.read_at(buf, offset).map_err(Into::into) +} + +pub(crate) fn fd_pwrite(file: &File, buf: &[u8], offset: wasi::__wasi_filesize_t) -> Result<usize> { + file.write_at(buf, offset).map_err(Into::into) +} + +pub(crate) fn fd_fdstat_get(fd: &File) -> Result<wasi::__wasi_fdflags_t> { + unsafe { yanix::fcntl::get_status_flags(fd.as_raw_fd()) } + .map(host_impl::fdflags_from_nix) + .map_err(Into::into) +} + +pub(crate) fn fd_fdstat_set_flags(fd: &File, fdflags: wasi::__wasi_fdflags_t) -> Result<()> { + let nix_flags = host_impl::nix_from_fdflags(fdflags); + unsafe { yanix::fcntl::set_status_flags(fd.as_raw_fd(), nix_flags) }.map_err(Into::into) +} + +pub(crate) fn fd_advise( + file: &File, + advice: wasi::__wasi_advice_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, +) -> Result<()> { + use yanix::fadvise::{posix_fadvise, PosixFadviseAdvice}; + let offset = offset.try_into()?; + let len = len.try_into()?; + let host_advice = match advice { + wasi::__WASI_ADVICE_DONTNEED => PosixFadviseAdvice::DontNeed, + wasi::__WASI_ADVICE_SEQUENTIAL => PosixFadviseAdvice::Sequential, + wasi::__WASI_ADVICE_WILLNEED => PosixFadviseAdvice::WillNeed, + wasi::__WASI_ADVICE_NOREUSE => PosixFadviseAdvice::NoReuse, + wasi::__WASI_ADVICE_RANDOM => PosixFadviseAdvice::Random, + wasi::__WASI_ADVICE_NORMAL => PosixFadviseAdvice::Normal, + _ => return Err(Error::EINVAL), + }; + unsafe { posix_fadvise(file.as_raw_fd(), offset, len, host_advice) }.map_err(Into::into) +} + +pub(crate) fn path_create_directory(resolved: PathGet) -> Result<()> { + use yanix::file::{mkdirat, Mode}; + unsafe { + mkdirat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + Mode::from_bits_truncate(0o777), + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_link(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> { + use yanix::file::{linkat, AtFlag}; + unsafe { + linkat( + resolved_old.dirfd().as_raw_fd(), + resolved_old.path(), + resolved_new.dirfd().as_raw_fd(), + resolved_new.path(), + AtFlag::SYMLINK_FOLLOW, + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_open( + resolved: PathGet, + read: bool, + write: bool, + oflags: wasi::__wasi_oflags_t, + fs_flags: wasi::__wasi_fdflags_t, +) -> Result<File> { + use yanix::{ + file::{fstatat, openat, AtFlag, Mode, OFlag, SFlag}, + Errno, + }; + + let mut nix_all_oflags = if read && write { + OFlag::RDWR + } else if write { + OFlag::WRONLY + } else { + OFlag::RDONLY + }; + + // on non-Capsicum systems, we always want nofollow + nix_all_oflags.insert(OFlag::NOFOLLOW); + + // convert open flags + nix_all_oflags.insert(host_impl::nix_from_oflags(oflags)); + + // convert file descriptor flags + nix_all_oflags.insert(host_impl::nix_from_fdflags(fs_flags)); + + // Call openat. Use mode 0o666 so that we follow whatever the user's + // umask is, but don't set the executable flag, because it isn't yet + // meaningful for WASI programs to create executable files. + + log::debug!("path_open resolved = {:?}", resolved); + log::debug!("path_open oflags = {:?}", nix_all_oflags); + + let new_fd = match unsafe { + openat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + nix_all_oflags, + Mode::from_bits_truncate(0o666), + ) + } { + Ok(fd) => fd, + Err(e) => { + if let yanix::YanixError::Errno(errno) = e { + match errno { + // Linux returns ENXIO instead of EOPNOTSUPP when opening a socket + Errno::ENXIO => { + if let Ok(stat) = unsafe { + fstatat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::SYMLINK_NOFOLLOW, + ) + } { + if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::IFSOCK) { + return Err(Error::ENOTSUP); + } else { + return Err(Error::ENXIO); + } + } else { + return Err(Error::ENXIO); + } + } + // Linux returns ENOTDIR instead of ELOOP when using O_NOFOLLOW|O_DIRECTORY + // on a symlink. + Errno::ENOTDIR + if !(nix_all_oflags & (OFlag::NOFOLLOW | OFlag::DIRECTORY)).is_empty() => + { + if let Ok(stat) = unsafe { + fstatat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::SYMLINK_NOFOLLOW, + ) + } { + if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::IFLNK) { + return Err(Error::ELOOP); + } + } + return Err(Error::ENOTDIR); + } + // FreeBSD returns EMLINK instead of ELOOP when using O_NOFOLLOW on + // a symlink. + Errno::EMLINK if !(nix_all_oflags & OFlag::NOFOLLOW).is_empty() => { + return Err(Error::ELOOP); + } + errno => return Err(errno.into()), + } + } else { + return Err(e.into()); + } + } + }; + + log::debug!("path_open (host) new_fd = {:?}", new_fd); + + // Determine the type of the new file descriptor and which rights contradict with this type + Ok(unsafe { File::from_raw_fd(new_fd) }) +} + +pub(crate) fn path_readlink(resolved: PathGet, buf: &mut [u8]) -> Result<usize> { + use std::cmp::min; + use yanix::file::readlinkat; + let read_link = unsafe { readlinkat(resolved.dirfd().as_raw_fd(), resolved.path()) } + .map_err(Into::into) + .and_then(host_impl::path_from_host)?; + let copy_len = min(read_link.len(), buf.len()); + if copy_len > 0 { + buf[..copy_len].copy_from_slice(&read_link.as_bytes()[..copy_len]); + } + Ok(copy_len) +} + +pub(crate) fn fd_filestat_get(file: &std::fs::File) -> Result<wasi::__wasi_filestat_t> { + use yanix::file::fstat; + unsafe { fstat(file.as_raw_fd()) } + .map_err(Into::into) + .and_then(host_impl::filestat_from_nix) +} + +pub(crate) fn path_filestat_get( + resolved: PathGet, + dirflags: wasi::__wasi_lookupflags_t, +) -> Result<wasi::__wasi_filestat_t> { + use yanix::file::{fstatat, AtFlag}; + let atflags = match dirflags { + 0 => AtFlag::empty(), + _ => AtFlag::SYMLINK_NOFOLLOW, + }; + unsafe { fstatat(resolved.dirfd().as_raw_fd(), resolved.path(), atflags) } + .map_err(Into::into) + .and_then(host_impl::filestat_from_nix) +} + +pub(crate) fn path_filestat_set_times( + resolved: PathGet, + dirflags: wasi::__wasi_lookupflags_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + use super::super::filetime::*; + use std::time::{Duration, UNIX_EPOCH}; + + let set_atim = fst_flags & wasi::__WASI_FSTFLAGS_ATIM != 0; + let set_atim_now = fst_flags & wasi::__WASI_FSTFLAGS_ATIM_NOW != 0; + let set_mtim = fst_flags & wasi::__WASI_FSTFLAGS_MTIM != 0; + let set_mtim_now = fst_flags & wasi::__WASI_FSTFLAGS_MTIM_NOW != 0; + + if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) { + return Err(Error::EINVAL); + } + + let symlink_nofollow = wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW != dirflags; + let atim = if set_atim { + let time = UNIX_EPOCH + Duration::from_nanos(st_atim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) + } else if set_atim_now { + FileTime::Now + } else { + FileTime::Omit + }; + let mtim = if set_mtim { + let time = UNIX_EPOCH + Duration::from_nanos(st_mtim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) + } else if set_mtim_now { + FileTime::Now + } else { + FileTime::Omit + }; + + utimensat( + resolved.dirfd(), + resolved.path(), + atim, + mtim, + symlink_nofollow, + ) + .map_err(Into::into) +} + +pub(crate) fn path_remove_directory(resolved: PathGet) -> Result<()> { + use yanix::file::{unlinkat, AtFlag}; + unsafe { + unlinkat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::REMOVEDIR, + ) + } + .map_err(Into::into) +} + +pub(crate) fn fd_readdir<'a>( + os_handle: &'a mut OsHandle, + cookie: wasi::__wasi_dircookie_t, +) -> Result<impl Iterator<Item = Result<Dirent>> + 'a> { + use yanix::dir::{DirIter, Entry, EntryExt, SeekLoc}; + + // Get an instance of `Dir`; this is host-specific due to intricasies + // of managing a dir stream between Linux and BSD *nixes + let mut dir = fd_readdir_impl::get_dir_from_os_handle(os_handle)?; + + // Seek if needed. Unless cookie is wasi::__WASI_DIRCOOKIE_START, + // new items may not be returned to the caller. + if cookie == wasi::__WASI_DIRCOOKIE_START { + log::trace!(" | fd_readdir: doing rewinddir"); + dir.rewind(); + } else { + log::trace!(" | fd_readdir: doing seekdir to {}", cookie); + let loc = unsafe { SeekLoc::from_raw(cookie as i64)? }; + dir.seek(loc); + } + + Ok(DirIter::new(dir).map(|entry| { + let entry: Entry = entry?; + Ok(Dirent { + name: entry + // TODO can we reuse path_from_host for CStr? + .file_name() + .to_str()? + .to_owned(), + ino: entry.ino(), + ftype: entry.file_type().into(), + cookie: entry.seek_loc()?.to_raw().try_into()?, + }) + })) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::old::snapshot_0::sys::host_impl; +use crate::old::snapshot_0::{wasi, Result}; +use std::fs::File; +use yanix::file::OFlag; + +pub(crate) fn path_open_rights( + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + oflags: wasi::__wasi_oflags_t, + fs_flags: wasi::__wasi_fdflags_t, +) -> (wasi::__wasi_rights_t, wasi::__wasi_rights_t) { + // which rights are needed on the dirfd? + let mut needed_base = wasi::__WASI_RIGHTS_PATH_OPEN; + let mut needed_inheriting = rights_base | rights_inheriting; + + // convert open flags + let oflags = host_impl::nix_from_oflags(oflags); + if oflags.contains(OFlag::CREAT) { + needed_base |= wasi::__WASI_RIGHTS_PATH_CREATE_FILE; + } + if oflags.contains(OFlag::TRUNC) { + needed_base |= wasi::__WASI_RIGHTS_PATH_FILESTAT_SET_SIZE; + } + + // convert file descriptor flags + let fdflags = host_impl::nix_from_fdflags(fs_flags); + if fdflags.contains(OFlag::DSYNC) { + needed_inheriting |= wasi::__WASI_RIGHTS_FD_DATASYNC; + } + if fdflags.intersects(host_impl::O_RSYNC | OFlag::SYNC) { + needed_inheriting |= wasi::__WASI_RIGHTS_FD_SYNC; + } + + (needed_base, needed_inheriting) +} + +pub(crate) fn openat(dirfd: &File, path: &str) -> Result<File> { + use std::os::unix::prelude::{AsRawFd, FromRawFd}; + use yanix::file::{openat, Mode}; + + log::debug!("path_get openat path = {:?}", path); + + unsafe { + openat( + dirfd.as_raw_fd(), + path, + OFlag::RDONLY | OFlag::DIRECTORY | OFlag::NOFOLLOW, + Mode::empty(), + ) + } + .map(|new_fd| unsafe { File::from_raw_fd(new_fd) }) + .map_err(Into::into) +} + +pub(crate) fn readlinkat(dirfd: &File, path: &str) -> Result<String> { + use std::os::unix::prelude::AsRawFd; + use yanix::file::readlinkat; + + log::debug!("path_get readlinkat path = {:?}", path); + + unsafe { readlinkat(dirfd.as_raw_fd(), path) } + .map_err(Into::into) + .and_then(host_impl::path_from_host) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::old::snapshot_0::hostcalls_impl::{ClockEventData, FdEventData}; +use crate::old::snapshot_0::{wasi, Error, Result}; +use yanix::clock::{clock_getres, clock_gettime, ClockId}; + +fn wasi_clock_id_to_unix(clock_id: wasi::__wasi_clockid_t) -> Result<ClockId> { + // convert the supported clocks to libc types, or return EINVAL + match clock_id { + wasi::__WASI_CLOCKID_REALTIME => Ok(ClockId::Realtime), + wasi::__WASI_CLOCKID_MONOTONIC => Ok(ClockId::Monotonic), + wasi::__WASI_CLOCKID_PROCESS_CPUTIME_ID => Ok(ClockId::ProcessCPUTime), + wasi::__WASI_CLOCKID_THREAD_CPUTIME_ID => Ok(ClockId::ThreadCPUTime), + _ => Err(Error::EINVAL), + } +} + +pub(crate) fn clock_res_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> { + let clock_id = wasi_clock_id_to_unix(clock_id)?; + let timespec = clock_getres(clock_id)?; + + // convert to nanoseconds, returning EOVERFLOW in case of overflow; + // this is freelancing a bit from the spec but seems like it'll + // be an unusual situation to hit + (timespec.tv_sec as wasi::__wasi_timestamp_t) + .checked_mul(1_000_000_000) + .and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as wasi::__wasi_timestamp_t)) + .map_or(Err(Error::EOVERFLOW), |resolution| { + // a supported clock can never return zero; this case will probably never get hit, but + // make sure we follow the spec + if resolution == 0 { + Err(Error::EINVAL) + } else { + Ok(resolution) + } + }) +} + +pub(crate) fn clock_time_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> { + let clock_id = wasi_clock_id_to_unix(clock_id)?; + let timespec = clock_gettime(clock_id)?; + + // convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit + // from the spec but seems like it'll be an unusual situation to hit + (timespec.tv_sec as wasi::__wasi_timestamp_t) + .checked_mul(1_000_000_000) + .and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as wasi::__wasi_timestamp_t)) + .map_or(Err(Error::EOVERFLOW), Ok) +} + +pub(crate) fn poll_oneoff( + timeout: Option<ClockEventData>, + fd_events: Vec<FdEventData>, + events: &mut Vec<wasi::__wasi_event_t>, +) -> Result<()> { + use std::{convert::TryInto, os::unix::prelude::AsRawFd}; + use yanix::{ + poll::{poll, PollFd, PollFlags}, + Errno, + }; + + if fd_events.is_empty() && timeout.is_none() { + return Ok(()); + } + + let mut poll_fds: Vec<_> = fd_events + .iter() + .map(|event| { + let mut flags = PollFlags::empty(); + match event.r#type { + wasi::__WASI_EVENTTYPE_FD_READ => flags.insert(PollFlags::POLLIN), + wasi::__WASI_EVENTTYPE_FD_WRITE => flags.insert(PollFlags::POLLOUT), + // An event on a file descriptor can currently only be of type FD_READ or FD_WRITE + // Nothing else has been defined in the specification, and these are also the only two + // events we filtered before. If we get something else here, the code has a serious bug. + _ => unreachable!(), + }; + unsafe { PollFd::new(event.descriptor.as_raw_fd(), flags) } + }) + .collect(); + + let poll_timeout = timeout.map_or(-1, |timeout| { + let delay = timeout.delay / 1_000_000; // poll syscall requires delay to expressed in milliseconds + delay.try_into().unwrap_or(libc::c_int::max_value()) + }); + log::debug!("poll_oneoff poll_timeout = {:?}", poll_timeout); + + let ready = loop { + match poll(&mut poll_fds, poll_timeout) { + Err(_) => { + if Errno::last() == Errno::EINTR { + continue; + } + return Err(Errno::last().into()); + } + Ok(ready) => break ready, + } + }; + + Ok(if ready == 0 { + poll_oneoff_handle_timeout_event(timeout.expect("timeout should not be None"), events) + } else { + let ready_events = fd_events.into_iter().zip(poll_fds.into_iter()).take(ready); + poll_oneoff_handle_fd_event(ready_events, events)? + }) +} + +fn poll_oneoff_handle_timeout_event( + timeout: ClockEventData, + events: &mut Vec<wasi::__wasi_event_t>, +) { + events.push(wasi::__wasi_event_t { + userdata: timeout.userdata, + r#type: wasi::__WASI_EVENTTYPE_CLOCK, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: 0, + }, + }, + }); +} + +fn poll_oneoff_handle_fd_event<'a>( + ready_events: impl Iterator<Item = (FdEventData<'a>, yanix::poll::PollFd)>, + events: &mut Vec<wasi::__wasi_event_t>, +) -> Result<()> { + use std::{convert::TryInto, os::unix::prelude::AsRawFd}; + use yanix::{file::fionread, poll::PollFlags}; + + for (fd_event, poll_fd) in ready_events { + log::debug!("poll_oneoff_handle_fd_event fd_event = {:?}", fd_event); + log::debug!("poll_oneoff_handle_fd_event poll_fd = {:?}", poll_fd); + + let revents = match poll_fd.revents() { + Some(revents) => revents, + None => continue, + }; + + log::debug!("poll_oneoff_handle_fd_event revents = {:?}", revents); + + let nbytes = if fd_event.r#type == wasi::__WASI_EVENTTYPE_FD_READ { + unsafe { fionread(fd_event.descriptor.as_raw_fd())? } + } else { + 0 + }; + + let output_event = if revents.contains(PollFlags::POLLNVAL) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_BADF, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLERR) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_IO, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLHUP) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLIN) | revents.contains(PollFlags::POLLOUT) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: nbytes.try_into()?, + flags: 0, + }, + }, + } + } else { + continue; + }; + + events.push(output_event); + } + + Ok(()) +} +
1 +2 +3 +4 +5 +6 +7 +8 +
+//! Unix-specific hostcalls that implement +//! [WASI](https://github.com/bytecodealliance/wasmtime-wasi/blob/wasi/docs/WASI-overview.md). +mod fs; +pub(crate) mod fs_helpers; +mod misc; + +pub(crate) use self::fs::*; +pub(crate) use self::misc::*; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +
+//! This internal module consists of helper types and functions for dealing +//! with setting the file times specific to Linux. +use crate::old::snapshot_0::{sys::unix::filetime::FileTime, Result}; +use std::fs::File; +use std::io; +use std::sync::atomic::{AtomicBool, Ordering::Relaxed}; + +pub(crate) const UTIME_NOW: i64 = 1_073_741_823; +pub(crate) const UTIME_OMIT: i64 = 1_073_741_822; + +/// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol +/// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is +/// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall. +/// The original implementation can be found here: [filetime::unix::linux::set_times] +/// +/// [filetime::unix::linux::set_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/linux.rs#L64 +pub(crate) fn utimensat( + dirfd: &File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> Result<()> { + use crate::old::snapshot_0::sys::unix::filetime::to_timespec; + use std::ffi::CString; + use std::os::unix::prelude::*; + + let flags = if symlink_nofollow { + libc::AT_SYMLINK_NOFOLLOW + } else { + 0 + }; + + // Attempt to use the `utimensat` syscall, but if it's not supported by the + // current kernel then fall back to an older syscall. + static INVALID: AtomicBool = AtomicBool::new(false); + if !INVALID.load(Relaxed) { + let p = CString::new(path.as_bytes())?; + let times = [to_timespec(&atime)?, to_timespec(&mtime)?]; + let rc = unsafe { + libc::syscall( + libc::SYS_utimensat, + dirfd.as_raw_fd(), + p.as_ptr(), + times.as_ptr(), + flags, + ) + }; + if rc == 0 { + return Ok(()); + } + let err = io::Error::last_os_error(); + if err.raw_os_error() == Some(libc::ENOSYS) { + INVALID.store(true, Relaxed); + } else { + return Err(err.into()); + } + } + + super::utimesat::utimesat(dirfd, path, atime, mtime, symlink_nofollow) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +
+use crate::old::snapshot_0::{wasi, Result}; +use std::convert::TryInto; + +pub(crate) const O_RSYNC: yanix::file::OFlag = yanix::file::OFlag::RSYNC; + +pub(crate) fn stdev_from_nix(dev: libc::dev_t) -> Result<wasi::__wasi_device_t> { + Ok(wasi::__wasi_device_t::from(dev)) +} + +pub(crate) fn stino_from_nix(ino: libc::ino_t) -> Result<wasi::__wasi_inode_t> { + Ok(wasi::__wasi_device_t::from(ino)) +} + +pub(crate) fn stnlink_from_nix(nlink: libc::nlink_t) -> Result<wasi::__wasi_linkcount_t> { + nlink.try_into().map_err(Into::into) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +
+use crate::old::snapshot_0::hostcalls_impl::PathGet; +use crate::old::snapshot_0::Result; +use std::os::unix::prelude::AsRawFd; + +pub(crate) fn path_unlink_file(resolved: PathGet) -> Result<()> { + use yanix::file::{unlinkat, AtFlag}; + unsafe { + unlinkat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::empty(), + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_symlink(old_path: &str, resolved: PathGet) -> Result<()> { + use yanix::file::symlinkat; + + log::debug!("path_symlink old_path = {:?}", old_path); + log::debug!("path_symlink resolved = {:?}", resolved); + + unsafe { symlinkat(old_path, resolved.dirfd().as_raw_fd(), resolved.path()) } + .map_err(Into::into) +} + +pub(crate) fn path_rename(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> { + use yanix::file::renameat; + unsafe { + renameat( + resolved_old.dirfd().as_raw_fd(), + resolved_old.path(), + resolved_new.dirfd().as_raw_fd(), + resolved_new.path(), + ) + } + .map_err(Into::into) +} + +pub(crate) mod fd_readdir_impl { + use crate::old::snapshot_0::sys::fdentry_impl::OsHandle; + use crate::old::snapshot_0::Result; + use yanix::dir::Dir; + + pub(crate) fn get_dir_from_os_handle(os_handle: &mut OsHandle) -> Result<Box<Dir>> { + // We need to duplicate the fd, because `opendir(3)`: + // After a successful call to fdopendir(), fd is used internally by the implementation, + // and should not otherwise be used by the application. + // `opendir(3p)` also says that it's undefined behavior to + // modify the state of the fd in a different way than by accessing DIR*. + // + // Still, rewinddir will be needed because the two file descriptors + // share progress. But we can safely execute closedir now. + let fd = os_handle.try_clone()?; + // TODO This doesn't look very clean. Can we do something about it? + // Boxing is needed here in order to satisfy `yanix`'s trait requirement for the `DirIter` + // where `T: Deref<Target = Dir>`. + Ok(Box::new(Dir::from(fd)?)) + } +} +
1 +2 +3 +4 +5 +
+pub(crate) mod filetime; +pub(crate) mod host_impl; +pub(crate) mod hostcalls_impl; +pub(crate) mod oshandle; +pub(crate) mod utimesat; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +
+use std::fs; +use std::ops::{Deref, DerefMut}; +use std::os::unix::prelude::{AsRawFd, RawFd}; + +#[derive(Debug)] +pub(crate) struct OsHandle(fs::File); + +impl From<fs::File> for OsHandle { + fn from(file: fs::File) -> Self { + Self(file) + } +} + +impl AsRawFd for OsHandle { + fn as_raw_fd(&self) -> RawFd { + self.0.as_raw_fd() + } +} + +impl Deref for OsHandle { + type Target = fs::File; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for OsHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +
+use crate::old::snapshot_0::sys::unix::filetime::FileTime; +use crate::old::snapshot_0::Result; +use std::{fs, io}; + +/// Combines `openat` with `utimes` to emulate `utimensat` on platforms where it is +/// not available. The logic for setting file times is based on [filetime::unix::set_file_handles_times]. +/// +/// [filetime::unix::set_file_handles_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L24 +pub(crate) fn utimesat( + dirfd: &fs::File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> Result<()> { + use std::ffi::CString; + use std::os::unix::prelude::*; + // emulate *at syscall by reading the path from a combination of + // (fd, path) + let p = CString::new(path.as_bytes())?; + let mut flags = libc::O_RDWR; + if symlink_nofollow { + flags |= libc::O_NOFOLLOW; + } + let fd = unsafe { libc::openat(dirfd.as_raw_fd(), p.as_ptr(), flags) }; + let f = unsafe { fs::File::from_raw_fd(fd) }; + let (atime, mtime) = get_times(atime, mtime, || f.metadata().map_err(Into::into))?; + let times = [to_timeval(atime), to_timeval(mtime)]; + let rc = unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) }; + if rc == 0 { + Ok(()) + } else { + Err(io::Error::last_os_error().into()) + } +} + +/// Converts `filetime::FileTime` to `libc::timeval`. This function was taken directly from +/// [filetime] crate. +/// +/// [filetime]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L93 +fn to_timeval(ft: filetime::FileTime) -> libc::timeval { + libc::timeval { + tv_sec: ft.seconds(), + tv_usec: (ft.nanoseconds() / 1000) as libc::suseconds_t, + } +} + +/// For a provided pair of access and modified `FileTime`s, converts the input to +/// `filetime::FileTime` used later in `utimensat` function. For variants `FileTime::Now` +/// and `FileTime::Omit`, this function will make two syscalls: either accessing current +/// system time, or accessing the file's metadata. +/// +/// The original implementation can be found here: [filetime::unix::get_times]. +/// +/// [filetime::unix::get_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L42 +fn get_times( + atime: FileTime, + mtime: FileTime, + current: impl Fn() -> Result<fs::Metadata>, +) -> Result<(filetime::FileTime, filetime::FileTime)> { + use std::time::SystemTime; + + let atime = match atime { + FileTime::Now => { + let time = SystemTime::now(); + filetime::FileTime::from_system_time(time) + } + FileTime::Omit => { + let meta = current()?; + filetime::FileTime::from_last_access_time(&meta) + } + FileTime::FileTime(ft) => ft, + }; + + let mtime = match mtime { + FileTime::Now => { + let time = SystemTime::now(); + filetime::FileTime::from_system_time(time) + } + FileTime::Omit => { + let meta = current()?; + filetime::FileTime::from_last_modification_time(&meta) + } + FileTime::FileTime(ft) => ft, + }; + + Ok((atime, mtime)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +
+pub(crate) mod fdentry_impl; +pub(crate) mod host_impl; +pub(crate) mod hostcalls_impl; + +mod filetime; + +cfg_if::cfg_if! { + if #[cfg(target_os = "linux")] { + mod linux; + use self::linux as sys_impl; + } else if #[cfg(target_os = "emscripten")] { + mod emscripten; + use self::emscripten as sys_impl; + } else if #[cfg(any(target_os = "macos", + target_os = "netbsd", + target_os = "freebsd", + target_os = "openbsd", + target_os = "ios", + target_os = "dragonfly"))] { + mod bsd; + use self::bsd as sys_impl; + } +} + +use crate::old::snapshot_0::Result; +use std::fs::{File, OpenOptions}; + +pub(crate) fn dev_null() -> Result<File> { + OpenOptions::new() + .read(true) + .write(true) + .open("/dev/null") + .map_err(Into::into) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +
+//! Types and constants shared between 32-bit and 64-bit wasi. Types involving +//! pointer or `usize`-sized data are excluded here, so this file only contains +//! fixed-size types, so it's host/target independent. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] + +use wig::witx_wasi_types; + +witx_wasi_types!("old/snapshot_0" "wasi_unstable"); + +pub(crate) const RIGHTS_ALL: __wasi_rights_t = __WASI_RIGHTS_FD_DATASYNC + | __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_SEEK + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_TELL + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_FD_ALLOCATE + | __WASI_RIGHTS_PATH_CREATE_DIRECTORY + | __WASI_RIGHTS_PATH_CREATE_FILE + | __WASI_RIGHTS_PATH_LINK_SOURCE + | __WASI_RIGHTS_PATH_LINK_TARGET + | __WASI_RIGHTS_PATH_OPEN + | __WASI_RIGHTS_FD_READDIR + | __WASI_RIGHTS_PATH_READLINK + | __WASI_RIGHTS_PATH_RENAME_SOURCE + | __WASI_RIGHTS_PATH_RENAME_TARGET + | __WASI_RIGHTS_PATH_FILESTAT_GET + | __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_PATH_SYMLINK + | __WASI_RIGHTS_PATH_UNLINK_FILE + | __WASI_RIGHTS_PATH_REMOVE_DIRECTORY + | __WASI_RIGHTS_POLL_FD_READWRITE + | __WASI_RIGHTS_SOCK_SHUTDOWN; + +// Block and character device interaction is outside the scope of +// WASI. Simply allow everything. +pub(crate) const RIGHTS_BLOCK_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_BLOCK_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_CHARACTER_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_CHARACTER_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Only allow directory operations on directories. Directories can only +// yield file descriptors to other directories and files. +pub(crate) const RIGHTS_DIRECTORY_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_PATH_CREATE_DIRECTORY + | __WASI_RIGHTS_PATH_CREATE_FILE + | __WASI_RIGHTS_PATH_LINK_SOURCE + | __WASI_RIGHTS_PATH_LINK_TARGET + | __WASI_RIGHTS_PATH_OPEN + | __WASI_RIGHTS_FD_READDIR + | __WASI_RIGHTS_PATH_READLINK + | __WASI_RIGHTS_PATH_RENAME_SOURCE + | __WASI_RIGHTS_PATH_RENAME_TARGET + | __WASI_RIGHTS_PATH_FILESTAT_GET + | __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_PATH_SYMLINK + | __WASI_RIGHTS_PATH_UNLINK_FILE + | __WASI_RIGHTS_PATH_REMOVE_DIRECTORY + | __WASI_RIGHTS_POLL_FD_READWRITE; +pub(crate) const RIGHTS_DIRECTORY_INHERITING: __wasi_rights_t = + RIGHTS_DIRECTORY_BASE | RIGHTS_REGULAR_FILE_BASE; + +// Operations that apply to regular files. +pub(crate) const RIGHTS_REGULAR_FILE_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_DATASYNC + | __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_SEEK + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_TELL + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_FD_ALLOCATE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_POLL_FD_READWRITE; +pub(crate) const RIGHTS_REGULAR_FILE_INHERITING: __wasi_rights_t = 0; + +// Operations that apply to sockets and socket pairs. +pub(crate) const RIGHTS_SOCKET_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_POLL_FD_READWRITE + | __WASI_RIGHTS_SOCK_SHUTDOWN; +pub(crate) const RIGHTS_SOCKET_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Operations that apply to TTYs. +pub(crate) const RIGHTS_TTY_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_POLL_FD_READWRITE; +#[allow(unused)] +pub(crate) const RIGHTS_TTY_INHERITING: __wasi_rights_t = 0; + +pub fn whence_to_str(whence: __wasi_whence_t) -> &'static str { + match whence { + __WASI_WHENCE_CUR => "__WASI_WHENCE_CUR", + __WASI_WHENCE_END => "__WASI_WHENCE_END", + __WASI_WHENCE_SET => "__WASI_WHENCE_SET", + other => panic!("Undefined whence value {:?}", other), + } +} + +pub const __WASI_DIRCOOKIE_START: __wasi_dircookie_t = 0; + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn bindgen_test_layout_wasi_dirent_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_dirent_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_next as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_next) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_namlen as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_namlen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_type as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_type) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_fd_readwrite_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_event_fd_readwrite_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_fd_readwrite_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_fd_readwrite_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_fd_readwrite_t>())).nbytes as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_fd_readwrite_t), + "::", + stringify!(nbytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_fd_readwrite_t>())).flags as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_fd_readwrite_t), + "::", + stringify!(flags) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_u_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_event_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_u_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_u_t>())).fd_readwrite as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_u_t), + "::", + stringify!(fd_readwrite) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_event_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).userdata as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).error as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).r#type as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(r#type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_event_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_event_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).userdata as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).error as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).r#type as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(r#type) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_fdstat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_fdstat_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_filetype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_flags as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_base as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_inheriting as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_inheriting) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_filestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_filestat_t>(), + 56usize, + concat!("Size of: ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).dev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).filetype as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).nlink as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).size as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).atim as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).mtim as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ctim as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ctim) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_clock_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_clock_t>(), + 40usize, + concat!("Size of: ", stringify!(__wasi_subscription_clock_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_clock_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_clock_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).identifier as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(identifier) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).id as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(clock_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).timeout as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(timeout) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).precision as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(precision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).flags as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(flags) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t( + ) { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_fd_readwrite_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_subscription_fd_readwrite_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_fd_readwrite_t>(), + 4usize, + concat!( + "Alignment of ", + stringify!(__wasi_subscription_fd_readwrite_t) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_fd_readwrite_t>())).file_descriptor + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_fd_readwrite_t), + "::", + stringify!(fd) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_u_t>(), + 40usize, + concat!("Size of: ", stringify!(__wasi_subscription_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_u_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_u_t>())).clock as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_u_t), + "::", + stringify!(clock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_u_t>())).fd_readwrite as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_u_t), + "::", + stringify!(fd_readwrite) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_t>(), + 56usize, + concat!("Size of: ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t>())).userdata as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t>())).r#type as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(r#type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_subscription_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_filestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_filestat_t>(), + 56usize, + concat!("Size of: ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_filestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).dev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).filetype as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).nlink as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).size as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).atim as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).mtim as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ctim as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ctim) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_fdstat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_fdstat_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_fdstat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_filetype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_flags as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_base as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_inheriting as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_inheriting) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_dirent_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_dirent_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_dirent_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_next as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_next) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_namlen as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_namlen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_type as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_type) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +
+//! Types and constants specific to 32-bit wasi. These are similar to the types +//! in the `host` module, but pointers and `usize` values are replaced with +//! `u32`-sized types. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] + +use crate::old::snapshot_0::wasi::*; +use wig::witx_wasi32_types; + +pub type uintptr_t = u32; +pub type size_t = u32; + +witx_wasi32_types!("old/snapshot_0" "wasi_unstable"); + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn bindgen_test_layout_wasi_ciovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_ciovec_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_ciovec_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf_len as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf_len) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_iovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_iovec_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_iovec_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf_len as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_dir_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_dir_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_dir_t>())).pr_name_len as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_dir_t), + "::", + stringify!(pr_name_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_u_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_u_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_u_t>())).dir as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_u_t), + "::", + stringify!(dir) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).pr_type as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(pr_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).u as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(u) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +
+use std::io::{IoSlice, Result, Write}; + +/// An adapter around a `Write` stream that guarantees that its output +/// is valid UTF-8 and contains no control characters. It does this by +/// replacing characters with inert control pictures and replacement +/// characters. +pub(crate) struct SandboxedTTYWriter<'writer, Writer> +where + Writer: Write, +{ + inner: &'writer mut Writer, +} + +impl<'writer, Writer> SandboxedTTYWriter<'writer, Writer> +where + Writer: Write, +{ + /// Construct a new `SandboxedTTYWriter` with the given inner `Writer`. + pub(crate) fn new(inner: &'writer mut Writer) -> Self { + Self { inner } + } + + /// Write a single character to the output. + pub(crate) fn write_char(&mut self, c: char) -> Result<()> { + self.inner.write( + match c { + '\u{0000}' => '␀', + '\u{0001}' => '␁', + '\u{0002}' => '␂', + '\u{0003}' => '␃', + '\u{0004}' => '␄', + '\u{0005}' => '␅', + '\u{0006}' => '␆', + '\u{0007}' => '␇', + '\u{0008}' => '␈', + '\u{0009}' => '\t', + '\u{000A}' => '\n', + '\u{000B}' => '␋', + '\u{000C}' => '␌', + '\u{000D}' => '\r', + '\u{000E}' => '␎', + '\u{000F}' => '␏', + '\u{0010}' => '␐', + '\u{0011}' => '␑', + '\u{0012}' => '␒', + '\u{0013}' => '␓', + '\u{0014}' => '␔', + '\u{0015}' => '␕', + '\u{0016}' => '␖', + '\u{0017}' => '␗', + '\u{0018}' => '␘', + '\u{0019}' => '␙', + '\u{001A}' => '␚', + '\u{001B}' => '␛', + '\u{001C}' => '␜', + '\u{001D}' => '␝', + '\u{001E}' => '␞', + '\u{001F}' => '␟', + '\u{007F}' => '␡', + x if x.is_control() => '�', + x => x, + } + .encode_utf8(&mut [0; 4]) // UTF-8 encoding of a `char` is at most 4 bytes. + .as_bytes(), + )?; + + Ok(()) + } + + /// Write a string to the output. + pub(crate) fn write_str(&mut self, s: &str) -> Result<usize> { + let mut result = 0; + + for c in s.chars() { + self.write_char(c)?; + // Note that we use the encoding length of the given char, rather than + // how many bytes we actually wrote, because our users don't know about + // what's really being written. + result += c.len_utf8(); + } + + Ok(result) + } +} + +impl<'writer, Writer> Write for SandboxedTTYWriter<'writer, Writer> +where + Writer: Write, +{ + fn write(&mut self, buf: &[u8]) -> Result<usize> { + let mut input = buf; + let mut result = 0; + + // Decode the string without heap-allocating it. See the example here + // for more details: + // https://doc.rust-lang.org/std/str/struct.Utf8Error.html#examples + loop { + match std::str::from_utf8(input) { + Ok(valid) => { + result += self.write_str(valid)?; + break; + } + Err(error) => { + let (valid, after_valid) = input.split_at(error.valid_up_to()); + result += self.write_str(unsafe { std::str::from_utf8_unchecked(valid) })?; + self.write_char('�')?; + + if let Some(invalid_sequence_length) = error.error_len() { + // An invalid sequence was encountered. Tell the application we've + // written those bytes (though actually, we replaced them with U+FFFD). + result += invalid_sequence_length; + // Set up `input` to resume writing after the end of the sequence. + input = &after_valid[invalid_sequence_length..]; + } else { + // The end of the buffer was encountered unexpectedly. Tell the application + // we've written out the remainder of the buffer. + result += after_valid.len(); + break; + } + } + } + } + + return Ok(result); + } + + fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize> { + // Terminal output is [not expected to be atomic], so just write all the + // individual buffers in sequence. + // + // [not expected to be atomic]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html#tag_16_474_08 + let mut total_written = 0; + + for buf in bufs { + let written = self.write(buf)?; + + total_written += written; + + // Stop at the first point where the OS writes less than we asked. + if written < buf.len() { + break; + } + } + + Ok(total_written) + } + + fn flush(&mut self) -> Result<()> { + self.inner.flush() + } +} + +#[cfg(test)] +mod tests { + use super::SandboxedTTYWriter; + use std::io::{Result, Write}; + + #[test] + fn basic() -> Result<()> { + let mut buffer = Vec::new(); + let mut safe = SandboxedTTYWriter::new(&mut buffer); + safe.write_str("a\0b\u{0080}")?; + safe.write_char('\u{0007}')?; + safe.write(&[0x80])?; + safe.write(&[0xed, 0xa0, 0x80, 0xff, 0xfe])?; + assert_eq!( + buffer, + "a\u{2400}b\u{FFFD}\u{2407}\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}".as_bytes() + ); + Ok(()) + } + + #[test] + fn how_many_replacements() -> Result<()> { + // See https://hsivonen.fi/broken-utf-8/ for background. + + let mut buffer = Vec::new(); + let mut safe = SandboxedTTYWriter::new(&mut buffer); + safe.write(&[0x80, 0x80, 0x80, 0x80])?; + assert_eq!(buffer, "\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}".as_bytes()); + + let mut buffer = Vec::new(); + let mut safe = SandboxedTTYWriter::new(&mut buffer); + safe.write(&[0xF0, 0x80, 0x80, 0x41])?; + assert_eq!(buffer, "\u{FFFD}\u{FFFD}\u{FFFD}A".as_bytes()); + + let mut buffer = Vec::new(); + let mut safe = SandboxedTTYWriter::new(&mut buffer); + safe.write(&[0xF0, 0x80, 0x80])?; + assert_eq!(buffer, "\u{FFFD}\u{FFFD}\u{FFFD}".as_bytes()); + + let mut buffer = Vec::new(); + let mut safe = SandboxedTTYWriter::new(&mut buffer); + safe.write(&[0xF4, 0x80, 0x80, 0xC0])?; + assert_eq!(buffer, "\u{FFFD}\u{FFFD}".as_bytes()); + + Ok(()) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +
+use cfg_if::cfg_if; + +cfg_if! { + if #[cfg(unix)] { + mod unix; + pub(crate) use unix::*; + pub use unix::preopen_dir; + } else if #[cfg(windows)] { + mod windows; + pub(crate) use windows::*; + pub use windows::preopen_dir; + } else { + compile_error!("wasi-common doesn't compile for this platform yet"); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +
+use crate::fdentry::{Descriptor, OsHandleRef}; +use crate::{sys::unix::sys_impl, wasi, Error, Result}; +use std::fs::File; +use std::io; +use std::mem::ManuallyDrop; +use std::os::unix::prelude::{AsRawFd, FileTypeExt, FromRawFd, RawFd}; + +pub(crate) use sys_impl::oshandle::*; + +impl AsRawFd for Descriptor { + fn as_raw_fd(&self) -> RawFd { + match self { + Self::OsHandle(file) => file.as_raw_fd(), + Self::Stdin => io::stdin().as_raw_fd(), + Self::Stdout => io::stdout().as_raw_fd(), + Self::Stderr => io::stderr().as_raw_fd(), + } + } +} + +pub(crate) fn descriptor_as_oshandle<'lifetime>( + desc: &'lifetime Descriptor, +) -> OsHandleRef<'lifetime> { + OsHandleRef::new(ManuallyDrop::new(OsHandle::from(unsafe { + File::from_raw_fd(desc.as_raw_fd()) + }))) +} + +/// Returns the set of all possible rights that are both relevant for the file +/// type and consistent with the open mode. +/// +/// This function is unsafe because it operates on a raw file descriptor. +pub(crate) unsafe fn determine_type_and_access_rights<Fd: AsRawFd>( + fd: &Fd, +) -> Result<( + wasi::__wasi_filetype_t, + wasi::__wasi_rights_t, + wasi::__wasi_rights_t, +)> { + let (file_type, mut rights_base, rights_inheriting) = determine_type_rights(fd)?; + + use yanix::{fcntl, file::OFlag}; + let flags = fcntl::get_status_flags(fd.as_raw_fd())?; + let accmode = flags & OFlag::ACCMODE; + if accmode == OFlag::RDONLY { + rights_base &= !wasi::__WASI_RIGHTS_FD_WRITE; + } else if accmode == OFlag::WRONLY { + rights_base &= !wasi::__WASI_RIGHTS_FD_READ; + } + + Ok((file_type, rights_base, rights_inheriting)) +} + +/// Returns the set of all possible rights that are relevant for file type. +/// +/// This function is unsafe because it operates on a raw file descriptor. +pub(crate) unsafe fn determine_type_rights<Fd: AsRawFd>( + fd: &Fd, +) -> Result<( + wasi::__wasi_filetype_t, + wasi::__wasi_rights_t, + wasi::__wasi_rights_t, +)> { + let (file_type, rights_base, rights_inheriting) = { + // we just make a `File` here for convenience; we don't want it to close when it drops + let file = std::mem::ManuallyDrop::new(std::fs::File::from_raw_fd(fd.as_raw_fd())); + let ft = file.metadata()?.file_type(); + if ft.is_block_device() { + log::debug!("Host fd {:?} is a block device", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_BLOCK_DEVICE, + wasi::RIGHTS_BLOCK_DEVICE_BASE, + wasi::RIGHTS_BLOCK_DEVICE_INHERITING, + ) + } else if ft.is_char_device() { + log::debug!("Host fd {:?} is a char device", fd.as_raw_fd()); + use yanix::file::isatty; + if isatty(fd.as_raw_fd())? { + ( + wasi::__WASI_FILETYPE_CHARACTER_DEVICE, + wasi::RIGHTS_TTY_BASE, + wasi::RIGHTS_TTY_BASE, + ) + } else { + ( + wasi::__WASI_FILETYPE_CHARACTER_DEVICE, + wasi::RIGHTS_CHARACTER_DEVICE_BASE, + wasi::RIGHTS_CHARACTER_DEVICE_INHERITING, + ) + } + } else if ft.is_dir() { + log::debug!("Host fd {:?} is a directory", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_DIRECTORY, + wasi::RIGHTS_DIRECTORY_BASE, + wasi::RIGHTS_DIRECTORY_INHERITING, + ) + } else if ft.is_file() { + log::debug!("Host fd {:?} is a file", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_REGULAR_FILE, + wasi::RIGHTS_REGULAR_FILE_BASE, + wasi::RIGHTS_REGULAR_FILE_INHERITING, + ) + } else if ft.is_socket() { + log::debug!("Host fd {:?} is a socket", fd.as_raw_fd()); + use yanix::socket::{get_socket_type, SockType}; + match get_socket_type(fd.as_raw_fd())? { + SockType::Datagram => ( + wasi::__WASI_FILETYPE_SOCKET_DGRAM, + wasi::RIGHTS_SOCKET_BASE, + wasi::RIGHTS_SOCKET_INHERITING, + ), + SockType::Stream => ( + wasi::__WASI_FILETYPE_SOCKET_STREAM, + wasi::RIGHTS_SOCKET_BASE, + wasi::RIGHTS_SOCKET_INHERITING, + ), + _ => return Err(Error::EINVAL), + } + } else if ft.is_fifo() { + log::debug!("Host fd {:?} is a fifo", fd.as_raw_fd()); + ( + wasi::__WASI_FILETYPE_UNKNOWN, + wasi::RIGHTS_REGULAR_FILE_BASE, + wasi::RIGHTS_REGULAR_FILE_INHERITING, + ) + } else { + log::debug!("Host fd {:?} is unknown", fd.as_raw_fd()); + return Err(Error::EINVAL); + } + }; + + Ok((file_type, rights_base, rights_inheriting)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +
+//! This internal module consists of helper types and functions for dealing +//! with setting the file times (mainly in `path_filestat_set_times` syscall for now). +//! +//! The vast majority of the code contained within and in platform-specific implementations +//! (`super::linux::filetime` and `super::bsd::filetime`) is based on the [filetime] crate. +//! Kudos @alexcrichton! +//! +//! [filetime]: https://github.com/alexcrichton/filetime +use crate::Result; +use std::convert::TryInto; + +pub(crate) use super::sys_impl::filetime::*; + +cfg_if::cfg_if! { + if #[cfg(not(target_os = "emscripten"))] { + fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { + Ok( + libc::timespec { + tv_sec: ft.seconds(), + tv_nsec: ft.nanoseconds().try_into()?, + } + ) + } + } else { + fn filetime_to_timespec(ft: &filetime::FileTime) -> Result<libc::timespec> { + Ok( + libc::timespec { + tv_sec: ft.seconds().try_into()?, + tv_nsec: ft.nanoseconds().try_into()?, + } + ) + } + } +} + +/// A wrapper `enum` around `filetime::FileTime` struct, but unlike the original, this +/// type allows the possibility of specifying `FileTime::Now` as a valid enumeration which, +/// in turn, if `utimensat` is available on the host, will use a special const setting +/// `UTIME_NOW`. +#[derive(Debug, Copy, Clone)] +pub(crate) enum FileTime { + Now, + Omit, + FileTime(filetime::FileTime), +} + +/// Converts `FileTime` to `libc::timespec`. If `FileTime::Now` variant is specified, this +/// resolves to `UTIME_NOW` special const, `FileTime::Omit` variant resolves to `UTIME_OMIT`, and +/// `FileTime::FileTime(ft)` where `ft := filetime::FileTime` uses [filetime] crate's original +/// implementation which can be found here: [filetime::unix::to_timespec]. +/// +/// [filetime]: https://github.com/alexcrichton/filetime +/// [filetime::unix::to_timespec]: https://github.com/alexcrichton/filetime/blob/master/src/unix/mod.rs#L30 +pub(crate) fn to_timespec(ft: &FileTime) -> Result<libc::timespec> { + let ts = match ft { + FileTime::Now => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_NOW, + }, + FileTime::Omit => libc::timespec { + tv_sec: 0, + tv_nsec: UTIME_OMIT, + }, + FileTime::FileTime(ft) => filetime_to_timespec(ft)?, + }; + Ok(ts) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +
+//! WASI host types specific to *nix host. +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] +use crate::host::FileType; +use crate::{error::FromRawOsError, helpers, sys::unix::sys_impl, wasi, Error, Result}; +use std::ffi::OsStr; +use std::os::unix::prelude::OsStrExt; +use yanix::{ + file::{OFlag, SFlag}, + Errno, +}; + +pub(crate) use sys_impl::host_impl::*; + +impl FromRawOsError for Error { + fn from_raw_os_error(code: i32) -> Self { + Self::from(Errno::from_i32(code)) + } +} + +impl From<Errno> for Error { + fn from(errno: Errno) -> Self { + match errno { + Errno::EPERM => Self::EPERM, + Errno::ENOENT => Self::ENOENT, + Errno::ESRCH => Self::ESRCH, + Errno::EINTR => Self::EINTR, + Errno::EIO => Self::EIO, + Errno::ENXIO => Self::ENXIO, + Errno::E2BIG => Self::E2BIG, + Errno::ENOEXEC => Self::ENOEXEC, + Errno::EBADF => Self::EBADF, + Errno::ECHILD => Self::ECHILD, + Errno::EAGAIN => Self::EAGAIN, + Errno::ENOMEM => Self::ENOMEM, + Errno::EACCES => Self::EACCES, + Errno::EFAULT => Self::EFAULT, + Errno::EBUSY => Self::EBUSY, + Errno::EEXIST => Self::EEXIST, + Errno::EXDEV => Self::EXDEV, + Errno::ENODEV => Self::ENODEV, + Errno::ENOTDIR => Self::ENOTDIR, + Errno::EISDIR => Self::EISDIR, + Errno::EINVAL => Self::EINVAL, + Errno::ENFILE => Self::ENFILE, + Errno::EMFILE => Self::EMFILE, + Errno::ENOTTY => Self::ENOTTY, + Errno::ETXTBSY => Self::ETXTBSY, + Errno::EFBIG => Self::EFBIG, + Errno::ENOSPC => Self::ENOSPC, + Errno::ESPIPE => Self::ESPIPE, + Errno::EROFS => Self::EROFS, + Errno::EMLINK => Self::EMLINK, + Errno::EPIPE => Self::EPIPE, + Errno::EDOM => Self::EDOM, + Errno::ERANGE => Self::ERANGE, + Errno::EDEADLK => Self::EDEADLK, + Errno::ENAMETOOLONG => Self::ENAMETOOLONG, + Errno::ENOLCK => Self::ENOLCK, + Errno::ENOSYS => Self::ENOSYS, + Errno::ENOTEMPTY => Self::ENOTEMPTY, + Errno::ELOOP => Self::ELOOP, + Errno::ENOMSG => Self::ENOMSG, + Errno::EIDRM => Self::EIDRM, + Errno::ENOLINK => Self::ENOLINK, + Errno::EPROTO => Self::EPROTO, + Errno::EMULTIHOP => Self::EMULTIHOP, + Errno::EBADMSG => Self::EBADMSG, + Errno::EOVERFLOW => Self::EOVERFLOW, + Errno::EILSEQ => Self::EILSEQ, + Errno::ENOTSOCK => Self::ENOTSOCK, + Errno::EDESTADDRREQ => Self::EDESTADDRREQ, + Errno::EMSGSIZE => Self::EMSGSIZE, + Errno::EPROTOTYPE => Self::EPROTOTYPE, + Errno::ENOPROTOOPT => Self::ENOPROTOOPT, + Errno::EPROTONOSUPPORT => Self::EPROTONOSUPPORT, + Errno::EAFNOSUPPORT => Self::EAFNOSUPPORT, + Errno::EADDRINUSE => Self::EADDRINUSE, + Errno::EADDRNOTAVAIL => Self::EADDRNOTAVAIL, + Errno::ENETDOWN => Self::ENETDOWN, + Errno::ENETUNREACH => Self::ENETUNREACH, + Errno::ENETRESET => Self::ENETRESET, + Errno::ECONNABORTED => Self::ECONNABORTED, + Errno::ECONNRESET => Self::ECONNRESET, + Errno::ENOBUFS => Self::ENOBUFS, + Errno::EISCONN => Self::EISCONN, + Errno::ENOTCONN => Self::ENOTCONN, + Errno::ETIMEDOUT => Self::ETIMEDOUT, + Errno::ECONNREFUSED => Self::ECONNREFUSED, + Errno::EHOSTUNREACH => Self::EHOSTUNREACH, + Errno::EALREADY => Self::EALREADY, + Errno::EINPROGRESS => Self::EINPROGRESS, + Errno::ESTALE => Self::ESTALE, + Errno::EDQUOT => Self::EDQUOT, + Errno::ECANCELED => Self::ECANCELED, + Errno::EOWNERDEAD => Self::EOWNERDEAD, + Errno::ENOTRECOVERABLE => Self::ENOTRECOVERABLE, + } + } +} + +pub(crate) fn nix_from_fdflags(fdflags: wasi::__wasi_fdflags_t) -> OFlag { + let mut nix_flags = OFlag::empty(); + if fdflags & wasi::__WASI_FDFLAGS_APPEND != 0 { + nix_flags.insert(OFlag::APPEND); + } + if fdflags & wasi::__WASI_FDFLAGS_DSYNC != 0 { + nix_flags.insert(OFlag::DSYNC); + } + if fdflags & wasi::__WASI_FDFLAGS_NONBLOCK != 0 { + nix_flags.insert(OFlag::NONBLOCK); + } + if fdflags & wasi::__WASI_FDFLAGS_RSYNC != 0 { + nix_flags.insert(O_RSYNC); + } + if fdflags & wasi::__WASI_FDFLAGS_SYNC != 0 { + nix_flags.insert(OFlag::SYNC); + } + nix_flags +} + +pub(crate) fn fdflags_from_nix(oflags: OFlag) -> wasi::__wasi_fdflags_t { + let mut fdflags = 0; + if oflags.contains(OFlag::APPEND) { + fdflags |= wasi::__WASI_FDFLAGS_APPEND; + } + if oflags.contains(OFlag::DSYNC) { + fdflags |= wasi::__WASI_FDFLAGS_DSYNC; + } + if oflags.contains(OFlag::NONBLOCK) { + fdflags |= wasi::__WASI_FDFLAGS_NONBLOCK; + } + if oflags.contains(O_RSYNC) { + fdflags |= wasi::__WASI_FDFLAGS_RSYNC; + } + if oflags.contains(OFlag::SYNC) { + fdflags |= wasi::__WASI_FDFLAGS_SYNC; + } + fdflags +} + +pub(crate) fn nix_from_oflags(oflags: wasi::__wasi_oflags_t) -> OFlag { + let mut nix_flags = OFlag::empty(); + if oflags & wasi::__WASI_OFLAGS_CREAT != 0 { + nix_flags.insert(OFlag::CREAT); + } + if oflags & wasi::__WASI_OFLAGS_DIRECTORY != 0 { + nix_flags.insert(OFlag::DIRECTORY); + } + if oflags & wasi::__WASI_OFLAGS_EXCL != 0 { + nix_flags.insert(OFlag::EXCL); + } + if oflags & wasi::__WASI_OFLAGS_TRUNC != 0 { + nix_flags.insert(OFlag::TRUNC); + } + nix_flags +} + +pub(crate) fn filetype_from_nix(sflags: SFlag) -> FileType { + if sflags.contains(SFlag::IFCHR) { + FileType::CharacterDevice + } else if sflags.contains(SFlag::IFBLK) { + FileType::BlockDevice + } else if sflags.contains(SFlag::IFSOCK) { + FileType::SocketStream + } else if sflags.contains(SFlag::IFDIR) { + FileType::Directory + } else if sflags.contains(SFlag::IFREG) { + FileType::RegularFile + } else if sflags.contains(SFlag::IFLNK) { + FileType::Symlink + } else { + FileType::Unknown + } +} + +pub(crate) fn filestat_from_nix(filestat: libc::stat) -> Result<wasi::__wasi_filestat_t> { + use std::convert::TryInto; + + fn filestat_to_timestamp(secs: u64, nsecs: u64) -> Result<wasi::__wasi_timestamp_t> { + secs.checked_mul(1_000_000_000) + .and_then(|sec_nsec| sec_nsec.checked_add(nsecs)) + .ok_or(Error::EOVERFLOW) + } + + let filetype = SFlag::from_bits_truncate(filestat.st_mode); + let dev = stdev_from_nix(filestat.st_dev)?; + let ino = stino_from_nix(filestat.st_ino)?; + let atim = filestat_to_timestamp( + filestat.st_atime.try_into()?, + filestat.st_atime_nsec.try_into()?, + )?; + let ctim = filestat_to_timestamp( + filestat.st_ctime.try_into()?, + filestat.st_ctime_nsec.try_into()?, + )?; + let mtim = filestat_to_timestamp( + filestat.st_mtime.try_into()?, + filestat.st_mtime_nsec.try_into()?, + )?; + + Ok(wasi::__wasi_filestat_t { + dev, + ino, + nlink: wasi::__wasi_linkcount_t::from(filestat.st_nlink), + size: filestat.st_size as wasi::__wasi_filesize_t, + atim, + ctim, + mtim, + filetype: filetype_from_nix(filetype).to_wasi(), + }) +} + +pub(crate) fn dirent_filetype_from_host( + host_entry: &libc::dirent, +) -> Result<wasi::__wasi_filetype_t> { + match host_entry.d_type { + libc::DT_FIFO => Ok(wasi::__WASI_FILETYPE_UNKNOWN), + libc::DT_CHR => Ok(wasi::__WASI_FILETYPE_CHARACTER_DEVICE), + libc::DT_DIR => Ok(wasi::__WASI_FILETYPE_DIRECTORY), + libc::DT_BLK => Ok(wasi::__WASI_FILETYPE_BLOCK_DEVICE), + libc::DT_REG => Ok(wasi::__WASI_FILETYPE_REGULAR_FILE), + libc::DT_LNK => Ok(wasi::__WASI_FILETYPE_SYMBOLIC_LINK), + libc::DT_SOCK => { + // TODO how to discriminate between STREAM and DGRAM? + // Perhaps, we should create a more general WASI filetype + // such as __WASI_FILETYPE_SOCKET, and then it would be + // up to the client to check whether it's actually + // STREAM or DGRAM? + Ok(wasi::__WASI_FILETYPE_UNKNOWN) + } + libc::DT_UNKNOWN => Ok(wasi::__WASI_FILETYPE_UNKNOWN), + _ => Err(Error::EINVAL), + } +} + +/// Creates owned WASI path from OS string. +/// +/// NB WASI spec requires OS string to be valid UTF-8. Otherwise, +/// `__WASI_ERRNO_ILSEQ` error is returned. +pub(crate) fn path_from_host<S: AsRef<OsStr>>(s: S) -> Result<String> { + helpers::path_from_slice(s.as_ref().as_bytes()).map(String::from) +} + +impl From<yanix::dir::FileType> for FileType { + fn from(ft: yanix::dir::FileType) -> Self { + use yanix::dir::FileType::*; + match ft { + RegularFile => Self::RegularFile, + Symlink => Self::Symlink, + Directory => Self::Directory, + BlockDevice => Self::BlockDevice, + CharacterDevice => Self::CharacterDevice, + /* Unknown | Socket | Fifo */ _ => Self::Unknown, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::host::Dirent; +use crate::hostcalls_impl::PathGet; +use crate::sys::{fdentry_impl::OsHandle, host_impl, unix::sys_impl}; +use crate::{wasi, Error, Result}; +use std::convert::TryInto; +use std::fs::File; +use std::os::unix::fs::FileExt; +use std::os::unix::prelude::{AsRawFd, FromRawFd}; + +pub(crate) use sys_impl::hostcalls_impl::*; + +pub(crate) fn fd_pread( + file: &File, + buf: &mut [u8], + offset: wasi::__wasi_filesize_t, +) -> Result<usize> { + file.read_at(buf, offset).map_err(Into::into) +} + +pub(crate) fn fd_pwrite(file: &File, buf: &[u8], offset: wasi::__wasi_filesize_t) -> Result<usize> { + file.write_at(buf, offset).map_err(Into::into) +} + +pub(crate) fn fd_fdstat_get(fd: &File) -> Result<wasi::__wasi_fdflags_t> { + unsafe { yanix::fcntl::get_status_flags(fd.as_raw_fd()) } + .map(host_impl::fdflags_from_nix) + .map_err(Into::into) +} + +pub(crate) fn fd_fdstat_set_flags( + fd: &File, + fdflags: wasi::__wasi_fdflags_t, +) -> Result<Option<OsHandle>> { + let nix_flags = host_impl::nix_from_fdflags(fdflags); + unsafe { yanix::fcntl::set_status_flags(fd.as_raw_fd(), nix_flags) } + .map(|_| None) + .map_err(Into::into) +} + +pub(crate) fn fd_advise( + file: &File, + advice: wasi::__wasi_advice_t, + offset: wasi::__wasi_filesize_t, + len: wasi::__wasi_filesize_t, +) -> Result<()> { + use yanix::fadvise::{posix_fadvise, PosixFadviseAdvice}; + let offset = offset.try_into()?; + let len = len.try_into()?; + let host_advice = match advice { + wasi::__WASI_ADVICE_DONTNEED => PosixFadviseAdvice::DontNeed, + wasi::__WASI_ADVICE_SEQUENTIAL => PosixFadviseAdvice::Sequential, + wasi::__WASI_ADVICE_WILLNEED => PosixFadviseAdvice::WillNeed, + wasi::__WASI_ADVICE_NOREUSE => PosixFadviseAdvice::NoReuse, + wasi::__WASI_ADVICE_RANDOM => PosixFadviseAdvice::Random, + wasi::__WASI_ADVICE_NORMAL => PosixFadviseAdvice::Normal, + _ => return Err(Error::EINVAL), + }; + unsafe { posix_fadvise(file.as_raw_fd(), offset, len, host_advice) }.map_err(Into::into) +} + +pub(crate) fn path_create_directory(resolved: PathGet) -> Result<()> { + use yanix::file::{mkdirat, Mode}; + unsafe { + mkdirat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + Mode::from_bits_truncate(0o777), + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_link(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> { + use yanix::file::{linkat, AtFlag}; + unsafe { + linkat( + resolved_old.dirfd().as_raw_fd(), + resolved_old.path(), + resolved_new.dirfd().as_raw_fd(), + resolved_new.path(), + AtFlag::SYMLINK_FOLLOW, + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_open( + resolved: PathGet, + read: bool, + write: bool, + oflags: wasi::__wasi_oflags_t, + fs_flags: wasi::__wasi_fdflags_t, +) -> Result<File> { + use yanix::{ + file::{fstatat, openat, AtFlag, Mode, OFlag, SFlag}, + Errno, + }; + + let mut nix_all_oflags = if read && write { + OFlag::RDWR + } else if write { + OFlag::WRONLY + } else { + OFlag::RDONLY + }; + + // on non-Capsicum systems, we always want nofollow + nix_all_oflags.insert(OFlag::NOFOLLOW); + + // convert open flags + nix_all_oflags.insert(host_impl::nix_from_oflags(oflags)); + + // convert file descriptor flags + nix_all_oflags.insert(host_impl::nix_from_fdflags(fs_flags)); + + // Call openat. Use mode 0o666 so that we follow whatever the user's + // umask is, but don't set the executable flag, because it isn't yet + // meaningful for WASI programs to create executable files. + + log::debug!("path_open resolved = {:?}", resolved); + log::debug!("path_open oflags = {:?}", nix_all_oflags); + + let new_fd = match unsafe { + openat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + nix_all_oflags, + Mode::from_bits_truncate(0o666), + ) + } { + Ok(fd) => fd, + Err(e) => { + if let yanix::YanixError::Errno(errno) = e { + match errno { + // Linux returns ENXIO instead of EOPNOTSUPP when opening a socket + Errno::ENXIO => { + if let Ok(stat) = unsafe { + fstatat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::SYMLINK_NOFOLLOW, + ) + } { + if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::IFSOCK) { + return Err(Error::ENOTSUP); + } else { + return Err(Error::ENXIO); + } + } else { + return Err(Error::ENXIO); + } + } + // Linux returns ENOTDIR instead of ELOOP when using O_NOFOLLOW|O_DIRECTORY + // on a symlink. + Errno::ENOTDIR + if !(nix_all_oflags & (OFlag::NOFOLLOW | OFlag::DIRECTORY)).is_empty() => + { + if let Ok(stat) = unsafe { + fstatat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::SYMLINK_NOFOLLOW, + ) + } { + if SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::IFLNK) { + return Err(Error::ELOOP); + } + } + return Err(Error::ENOTDIR); + } + // FreeBSD returns EMLINK instead of ELOOP when using O_NOFOLLOW on + // a symlink. + Errno::EMLINK if !(nix_all_oflags & OFlag::NOFOLLOW).is_empty() => { + return Err(Error::ELOOP); + } + errno => return Err(errno.into()), + } + } else { + return Err(e.into()); + } + } + }; + + log::debug!("path_open (host) new_fd = {:?}", new_fd); + + // Determine the type of the new file descriptor and which rights contradict with this type + Ok(unsafe { File::from_raw_fd(new_fd) }) +} + +pub(crate) fn path_readlink(resolved: PathGet, buf: &mut [u8]) -> Result<usize> { + use std::cmp::min; + use yanix::file::readlinkat; + let read_link = unsafe { readlinkat(resolved.dirfd().as_raw_fd(), resolved.path()) } + .map_err(Into::into) + .and_then(host_impl::path_from_host)?; + let copy_len = min(read_link.len(), buf.len()); + if copy_len > 0 { + buf[..copy_len].copy_from_slice(&read_link.as_bytes()[..copy_len]); + } + Ok(copy_len) +} + +pub(crate) fn fd_filestat_get(file: &std::fs::File) -> Result<wasi::__wasi_filestat_t> { + use yanix::file::fstat; + unsafe { fstat(file.as_raw_fd()) } + .map_err(Into::into) + .and_then(host_impl::filestat_from_nix) +} + +pub(crate) fn path_filestat_get( + resolved: PathGet, + dirflags: wasi::__wasi_lookupflags_t, +) -> Result<wasi::__wasi_filestat_t> { + use yanix::file::{fstatat, AtFlag}; + let atflags = match dirflags { + 0 => AtFlag::empty(), + _ => AtFlag::SYMLINK_NOFOLLOW, + }; + unsafe { fstatat(resolved.dirfd().as_raw_fd(), resolved.path(), atflags) } + .map_err(Into::into) + .and_then(host_impl::filestat_from_nix) +} + +pub(crate) fn path_filestat_set_times( + resolved: PathGet, + dirflags: wasi::__wasi_lookupflags_t, + st_atim: wasi::__wasi_timestamp_t, + st_mtim: wasi::__wasi_timestamp_t, + fst_flags: wasi::__wasi_fstflags_t, +) -> Result<()> { + use super::super::filetime::*; + use std::time::{Duration, UNIX_EPOCH}; + + let set_atim = fst_flags & wasi::__WASI_FSTFLAGS_ATIM != 0; + let set_atim_now = fst_flags & wasi::__WASI_FSTFLAGS_ATIM_NOW != 0; + let set_mtim = fst_flags & wasi::__WASI_FSTFLAGS_MTIM != 0; + let set_mtim_now = fst_flags & wasi::__WASI_FSTFLAGS_MTIM_NOW != 0; + + if (set_atim && set_atim_now) || (set_mtim && set_mtim_now) { + return Err(Error::EINVAL); + } + + let symlink_nofollow = wasi::__WASI_LOOKUPFLAGS_SYMLINK_FOLLOW != dirflags; + let atim = if set_atim { + let time = UNIX_EPOCH + Duration::from_nanos(st_atim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) + } else if set_atim_now { + FileTime::Now + } else { + FileTime::Omit + }; + let mtim = if set_mtim { + let time = UNIX_EPOCH + Duration::from_nanos(st_mtim); + FileTime::FileTime(filetime::FileTime::from_system_time(time)) + } else if set_mtim_now { + FileTime::Now + } else { + FileTime::Omit + }; + + utimensat( + resolved.dirfd(), + resolved.path(), + atim, + mtim, + symlink_nofollow, + ) + .map_err(Into::into) +} + +pub(crate) fn path_remove_directory(resolved: PathGet) -> Result<()> { + use yanix::file::{unlinkat, AtFlag}; + unsafe { + unlinkat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::REMOVEDIR, + ) + } + .map_err(Into::into) +} + +pub(crate) fn fd_readdir<'a>( + os_handle: &'a mut OsHandle, + cookie: wasi::__wasi_dircookie_t, +) -> Result<impl Iterator<Item = Result<Dirent>> + 'a> { + use yanix::dir::{DirIter, Entry, EntryExt, SeekLoc}; + + // Get an instance of `Dir`; this is host-specific due to intricasies + // of managing a dir stream between Linux and BSD *nixes + let mut dir = fd_readdir_impl::get_dir_from_os_handle(os_handle)?; + + // Seek if needed. Unless cookie is wasi::__WASI_DIRCOOKIE_START, + // new items may not be returned to the caller. + if cookie == wasi::__WASI_DIRCOOKIE_START { + log::trace!(" | fd_readdir: doing rewinddir"); + dir.rewind(); + } else { + log::trace!(" | fd_readdir: doing seekdir to {}", cookie); + let loc = unsafe { SeekLoc::from_raw(cookie as i64)? }; + dir.seek(loc); + } + + Ok(DirIter::new(dir).map(|entry| { + let entry: Entry = entry?; + Ok(Dirent { + name: entry + // TODO can we reuse path_from_host for CStr? + .file_name() + .to_str()? + .to_owned(), + ino: entry.ino(), + ftype: entry.file_type().into(), + cookie: entry.seek_loc()?.to_raw().try_into()?, + }) + })) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::sys::host_impl; +use crate::{wasi, Result}; +use std::fs::File; +use yanix::file::OFlag; + +pub(crate) fn path_open_rights( + rights_base: wasi::__wasi_rights_t, + rights_inheriting: wasi::__wasi_rights_t, + oflags: wasi::__wasi_oflags_t, + fs_flags: wasi::__wasi_fdflags_t, +) -> (wasi::__wasi_rights_t, wasi::__wasi_rights_t) { + // which rights are needed on the dirfd? + let mut needed_base = wasi::__WASI_RIGHTS_PATH_OPEN; + let mut needed_inheriting = rights_base | rights_inheriting; + + // convert open flags + let oflags = host_impl::nix_from_oflags(oflags); + if oflags.contains(OFlag::CREAT) { + needed_base |= wasi::__WASI_RIGHTS_PATH_CREATE_FILE; + } + if oflags.contains(OFlag::TRUNC) { + needed_base |= wasi::__WASI_RIGHTS_PATH_FILESTAT_SET_SIZE; + } + + // convert file descriptor flags + let fdflags = host_impl::nix_from_fdflags(fs_flags); + if fdflags.contains(OFlag::DSYNC) { + needed_inheriting |= wasi::__WASI_RIGHTS_FD_DATASYNC; + } + if fdflags.intersects(host_impl::O_RSYNC | OFlag::SYNC) { + needed_inheriting |= wasi::__WASI_RIGHTS_FD_SYNC; + } + + (needed_base, needed_inheriting) +} + +pub(crate) fn openat(dirfd: &File, path: &str) -> Result<File> { + use std::os::unix::prelude::{AsRawFd, FromRawFd}; + use yanix::file::{openat, Mode}; + + log::debug!("path_get openat path = {:?}", path); + + unsafe { + openat( + dirfd.as_raw_fd(), + path, + OFlag::RDONLY | OFlag::DIRECTORY | OFlag::NOFOLLOW, + Mode::empty(), + ) + } + .map(|new_fd| unsafe { File::from_raw_fd(new_fd) }) + .map_err(Into::into) +} + +pub(crate) fn readlinkat(dirfd: &File, path: &str) -> Result<String> { + use std::os::unix::prelude::AsRawFd; + use yanix::file::readlinkat; + + log::debug!("path_get readlinkat path = {:?}", path); + + unsafe { readlinkat(dirfd.as_raw_fd(), path) } + .map_err(Into::into) + .and_then(host_impl::path_from_host) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +
+#![allow(non_camel_case_types)] +#![allow(unused_unsafe)] +use crate::hostcalls_impl::{ClockEventData, FdEventData}; +use crate::{wasi, Error, Result}; +use yanix::clock::{clock_getres, clock_gettime, ClockId}; + +fn wasi_clock_id_to_unix(clock_id: wasi::__wasi_clockid_t) -> Result<ClockId> { + // convert the supported clocks to libc types, or return EINVAL + match clock_id { + wasi::__WASI_CLOCKID_REALTIME => Ok(ClockId::Realtime), + wasi::__WASI_CLOCKID_MONOTONIC => Ok(ClockId::Monotonic), + wasi::__WASI_CLOCKID_PROCESS_CPUTIME_ID => Ok(ClockId::ProcessCPUTime), + wasi::__WASI_CLOCKID_THREAD_CPUTIME_ID => Ok(ClockId::ThreadCPUTime), + _ => Err(Error::EINVAL), + } +} + +pub(crate) fn clock_res_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> { + let clock_id = wasi_clock_id_to_unix(clock_id)?; + let timespec = clock_getres(clock_id)?; + + // convert to nanoseconds, returning EOVERFLOW in case of overflow; + // this is freelancing a bit from the spec but seems like it'll + // be an unusual situation to hit + (timespec.tv_sec as wasi::__wasi_timestamp_t) + .checked_mul(1_000_000_000) + .and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as wasi::__wasi_timestamp_t)) + .map_or(Err(Error::EOVERFLOW), |resolution| { + // a supported clock can never return zero; this case will probably never get hit, but + // make sure we follow the spec + if resolution == 0 { + Err(Error::EINVAL) + } else { + Ok(resolution) + } + }) +} + +pub(crate) fn clock_time_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> { + let clock_id = wasi_clock_id_to_unix(clock_id)?; + let timespec = clock_gettime(clock_id)?; + + // convert to nanoseconds, returning EOVERFLOW in case of overflow; this is freelancing a bit + // from the spec but seems like it'll be an unusual situation to hit + (timespec.tv_sec as wasi::__wasi_timestamp_t) + .checked_mul(1_000_000_000) + .and_then(|sec_ns| sec_ns.checked_add(timespec.tv_nsec as wasi::__wasi_timestamp_t)) + .map_or(Err(Error::EOVERFLOW), Ok) +} + +pub(crate) fn poll_oneoff( + timeout: Option<ClockEventData>, + fd_events: Vec<FdEventData>, + events: &mut Vec<wasi::__wasi_event_t>, +) -> Result<()> { + use std::{convert::TryInto, os::unix::prelude::AsRawFd}; + use yanix::{ + poll::{poll, PollFd, PollFlags}, + Errno, + }; + + if fd_events.is_empty() && timeout.is_none() { + return Ok(()); + } + + let mut poll_fds: Vec<_> = fd_events + .iter() + .map(|event| { + let mut flags = PollFlags::empty(); + match event.r#type { + wasi::__WASI_EVENTTYPE_FD_READ => flags.insert(PollFlags::POLLIN), + wasi::__WASI_EVENTTYPE_FD_WRITE => flags.insert(PollFlags::POLLOUT), + // An event on a file descriptor can currently only be of type FD_READ or FD_WRITE + // Nothing else has been defined in the specification, and these are also the only two + // events we filtered before. If we get something else here, the code has a serious bug. + _ => unreachable!(), + }; + unsafe { PollFd::new(event.descriptor.as_raw_fd(), flags) } + }) + .collect(); + + let poll_timeout = timeout.map_or(-1, |timeout| { + let delay = timeout.delay / 1_000_000; // poll syscall requires delay to expressed in milliseconds + delay.try_into().unwrap_or(libc::c_int::max_value()) + }); + log::debug!("poll_oneoff poll_timeout = {:?}", poll_timeout); + + let ready = loop { + match poll(&mut poll_fds, poll_timeout) { + Err(_) => { + if Errno::last() == Errno::EINTR { + continue; + } + return Err(Errno::last().into()); + } + Ok(ready) => break ready, + } + }; + + Ok(if ready == 0 { + poll_oneoff_handle_timeout_event(timeout.expect("timeout should not be None"), events) + } else { + let ready_events = fd_events.into_iter().zip(poll_fds.into_iter()).take(ready); + poll_oneoff_handle_fd_event(ready_events, events)? + }) +} + +fn poll_oneoff_handle_timeout_event( + timeout: ClockEventData, + events: &mut Vec<wasi::__wasi_event_t>, +) { + events.push(wasi::__wasi_event_t { + userdata: timeout.userdata, + r#type: wasi::__WASI_EVENTTYPE_CLOCK, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: 0, + }, + }, + }); +} + +fn poll_oneoff_handle_fd_event<'a>( + ready_events: impl Iterator<Item = (FdEventData<'a>, yanix::poll::PollFd)>, + events: &mut Vec<wasi::__wasi_event_t>, +) -> Result<()> { + use std::{convert::TryInto, os::unix::prelude::AsRawFd}; + use yanix::{file::fionread, poll::PollFlags}; + + for (fd_event, poll_fd) in ready_events { + log::debug!("poll_oneoff_handle_fd_event fd_event = {:?}", fd_event); + log::debug!("poll_oneoff_handle_fd_event poll_fd = {:?}", poll_fd); + + let revents = match poll_fd.revents() { + Some(revents) => revents, + None => continue, + }; + + log::debug!("poll_oneoff_handle_fd_event revents = {:?}", revents); + + let nbytes = if fd_event.r#type == wasi::__WASI_EVENTTYPE_FD_READ { + unsafe { fionread(fd_event.descriptor.as_raw_fd())? } + } else { + 0 + }; + + let output_event = if revents.contains(PollFlags::POLLNVAL) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_BADF, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLERR) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_IO, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLHUP) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: 0, + flags: wasi::__WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP, + }, + }, + } + } else if revents.contains(PollFlags::POLLIN) | revents.contains(PollFlags::POLLOUT) { + wasi::__wasi_event_t { + userdata: fd_event.userdata, + r#type: fd_event.r#type, + error: wasi::__WASI_ERRNO_SUCCESS, + u: wasi::__wasi_event_u_t { + fd_readwrite: wasi::__wasi_event_fd_readwrite_t { + nbytes: nbytes.try_into()?, + flags: 0, + }, + }, + } + } else { + continue; + }; + + events.push(output_event); + } + + Ok(()) +} +
1 +2 +3 +4 +5 +6 +7 +8 +
+//! Unix-specific hostcalls that implement +//! [WASI](https://github.com/bytecodealliance/wasmtime-wasi/blob/wasi/docs/WASI-overview.md). +mod fs; +pub(crate) mod fs_helpers; +mod misc; + +pub(crate) use self::fs::*; +pub(crate) use self::misc::*; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +
+//! This internal module consists of helper types and functions for dealing +//! with setting the file times specific to Linux. +use crate::{sys::unix::filetime::FileTime, Result}; +use std::fs::File; +use std::io; +use std::sync::atomic::{AtomicBool, Ordering::Relaxed}; + +pub(crate) const UTIME_NOW: i64 = 1_073_741_823; +pub(crate) const UTIME_OMIT: i64 = 1_073_741_822; + +/// Wrapper for `utimensat` syscall, however, with an added twist such that `utimensat` symbol +/// is firstly resolved (i.e., we check whether it exists on the host), and only used if that is +/// the case. Otherwise, the syscall resorts to a less accurate `utimesat` emulated syscall. +/// The original implementation can be found here: [filetime::unix::linux::set_times] +/// +/// [filetime::unix::linux::set_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/linux.rs#L64 +pub(crate) fn utimensat( + dirfd: &File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> Result<()> { + use crate::sys::unix::filetime::to_timespec; + use std::ffi::CString; + use std::os::unix::prelude::*; + + let flags = if symlink_nofollow { + libc::AT_SYMLINK_NOFOLLOW + } else { + 0 + }; + + // Attempt to use the `utimensat` syscall, but if it's not supported by the + // current kernel then fall back to an older syscall. + static INVALID: AtomicBool = AtomicBool::new(false); + if !INVALID.load(Relaxed) { + let p = CString::new(path.as_bytes())?; + let times = [to_timespec(&atime)?, to_timespec(&mtime)?]; + let rc = unsafe { + libc::syscall( + libc::SYS_utimensat, + dirfd.as_raw_fd(), + p.as_ptr(), + times.as_ptr(), + flags, + ) + }; + if rc == 0 { + return Ok(()); + } + let err = io::Error::last_os_error(); + if err.raw_os_error() == Some(libc::ENOSYS) { + INVALID.store(true, Relaxed); + } else { + return Err(err.into()); + } + } + + super::utimesat::utimesat(dirfd, path, atime, mtime, symlink_nofollow) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +
+use crate::{wasi, Result}; + +pub(crate) const O_RSYNC: yanix::file::OFlag = yanix::file::OFlag::RSYNC; + +pub(crate) fn stdev_from_nix(dev: libc::dev_t) -> Result<wasi::__wasi_device_t> { + Ok(wasi::__wasi_device_t::from(dev)) +} + +pub(crate) fn stino_from_nix(ino: libc::ino_t) -> Result<wasi::__wasi_inode_t> { + Ok(wasi::__wasi_device_t::from(ino)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +
+use crate::hostcalls_impl::PathGet; +use crate::Result; +use std::os::unix::prelude::AsRawFd; + +pub(crate) fn path_unlink_file(resolved: PathGet) -> Result<()> { + use yanix::file::{unlinkat, AtFlag}; + unsafe { + unlinkat( + resolved.dirfd().as_raw_fd(), + resolved.path(), + AtFlag::empty(), + ) + } + .map_err(Into::into) +} + +pub(crate) fn path_symlink(old_path: &str, resolved: PathGet) -> Result<()> { + use yanix::file::symlinkat; + + log::debug!("path_symlink old_path = {:?}", old_path); + log::debug!("path_symlink resolved = {:?}", resolved); + + unsafe { symlinkat(old_path, resolved.dirfd().as_raw_fd(), resolved.path()) } + .map_err(Into::into) +} + +pub(crate) fn path_rename(resolved_old: PathGet, resolved_new: PathGet) -> Result<()> { + use yanix::file::renameat; + unsafe { + renameat( + resolved_old.dirfd().as_raw_fd(), + resolved_old.path(), + resolved_new.dirfd().as_raw_fd(), + resolved_new.path(), + ) + } + .map_err(Into::into) +} + +pub(crate) mod fd_readdir_impl { + use crate::sys::fdentry_impl::OsHandle; + use crate::Result; + use yanix::dir::Dir; + + pub(crate) fn get_dir_from_os_handle(os_handle: &mut OsHandle) -> Result<Box<Dir>> { + // We need to duplicate the fd, because `opendir(3)`: + // After a successful call to fdopendir(), fd is used internally by the implementation, + // and should not otherwise be used by the application. + // `opendir(3p)` also says that it's undefined behavior to + // modify the state of the fd in a different way than by accessing DIR*. + // + // Still, rewinddir will be needed because the two file descriptors + // share progress. But we can safely execute closedir now. + let fd = os_handle.try_clone()?; + // TODO This doesn't look very clean. Can we do something about it? + // Boxing is needed here in order to satisfy `yanix`'s trait requirement for the `DirIter` + // where `T: Deref<Target = Dir>`. + Ok(Box::new(Dir::from(fd)?)) + } +} +
1 +2 +3 +4 +5 +
+pub(crate) mod filetime; +pub(crate) mod host_impl; +pub(crate) mod hostcalls_impl; +pub(crate) mod oshandle; +pub(crate) mod utimesat; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +
+use std::fs; +use std::ops::{Deref, DerefMut}; +use std::os::unix::prelude::{AsRawFd, RawFd}; + +#[derive(Debug)] +pub(crate) struct OsHandle(fs::File); + +impl From<fs::File> for OsHandle { + fn from(file: fs::File) -> Self { + Self(file) + } +} + +impl AsRawFd for OsHandle { + fn as_raw_fd(&self) -> RawFd { + self.0.as_raw_fd() + } +} + +impl Deref for OsHandle { + type Target = fs::File; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for OsHandle { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +
+use crate::sys::unix::filetime::FileTime; +use crate::Result; +use std::{fs, io}; + +/// Combines `openat` with `utimes` to emulate `utimensat` on platforms where it is +/// not available. The logic for setting file times is based on [filetime::unix::set_file_handles_times]. +/// +/// [filetime::unix::set_file_handles_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L24 +pub(crate) fn utimesat( + dirfd: &fs::File, + path: &str, + atime: FileTime, + mtime: FileTime, + symlink_nofollow: bool, +) -> Result<()> { + use std::ffi::CString; + use std::os::unix::prelude::*; + // emulate *at syscall by reading the path from a combination of + // (fd, path) + let p = CString::new(path.as_bytes())?; + let mut flags = libc::O_RDWR; + if symlink_nofollow { + flags |= libc::O_NOFOLLOW; + } + let fd = unsafe { libc::openat(dirfd.as_raw_fd(), p.as_ptr(), flags) }; + let f = unsafe { fs::File::from_raw_fd(fd) }; + let (atime, mtime) = get_times(atime, mtime, || f.metadata().map_err(Into::into))?; + let times = [to_timeval(atime), to_timeval(mtime)]; + let rc = unsafe { libc::futimes(f.as_raw_fd(), times.as_ptr()) }; + if rc == 0 { + Ok(()) + } else { + Err(io::Error::last_os_error().into()) + } +} + +/// Converts `filetime::FileTime` to `libc::timeval`. This function was taken directly from +/// [filetime] crate. +/// +/// [filetime]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L93 +fn to_timeval(ft: filetime::FileTime) -> libc::timeval { + libc::timeval { + tv_sec: ft.seconds(), + tv_usec: (ft.nanoseconds() / 1000) as libc::suseconds_t, + } +} + +/// For a provided pair of access and modified `FileTime`s, converts the input to +/// `filetime::FileTime` used later in `utimensat` function. For variants `FileTime::Now` +/// and `FileTime::Omit`, this function will make two syscalls: either accessing current +/// system time, or accessing the file's metadata. +/// +/// The original implementation can be found here: [filetime::unix::get_times]. +/// +/// [filetime::unix::get_times]: https://github.com/alexcrichton/filetime/blob/master/src/unix/utimes.rs#L42 +fn get_times( + atime: FileTime, + mtime: FileTime, + current: impl Fn() -> Result<fs::Metadata>, +) -> Result<(filetime::FileTime, filetime::FileTime)> { + use std::time::SystemTime; + + let atime = match atime { + FileTime::Now => { + let time = SystemTime::now(); + filetime::FileTime::from_system_time(time) + } + FileTime::Omit => { + let meta = current()?; + filetime::FileTime::from_last_access_time(&meta) + } + FileTime::FileTime(ft) => ft, + }; + + let mtime = match mtime { + FileTime::Now => { + let time = SystemTime::now(); + filetime::FileTime::from_system_time(time) + } + FileTime::Omit => { + let meta = current()?; + filetime::FileTime::from_last_modification_time(&meta) + } + FileTime::FileTime(ft) => ft, + }; + + Ok((atime, mtime)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +
+pub(crate) mod fdentry_impl; +pub(crate) mod host_impl; +pub(crate) mod hostcalls_impl; + +mod filetime; + +cfg_if::cfg_if! { + if #[cfg(target_os = "linux")] { + mod linux; + use self::linux as sys_impl; + } else if #[cfg(target_os = "emscripten")] { + mod emscripten; + use self::emscripten as sys_impl; + } else if #[cfg(any(target_os = "macos", + target_os = "netbsd", + target_os = "freebsd", + target_os = "openbsd", + target_os = "ios", + target_os = "dragonfly"))] { + mod bsd; + use self::bsd as sys_impl; + } +} + +use crate::Result; +use std::fs::{File, OpenOptions}; +use std::path::Path; + +pub(crate) fn dev_null() -> Result<File> { + OpenOptions::new() + .read(true) + .write(true) + .open("/dev/null") + .map_err(Into::into) +} + +pub fn preopen_dir<P: AsRef<Path>>(path: P) -> Result<File> { + File::open(path).map_err(Into::into) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +
+//! Types and constants shared between 32-bit and 64-bit wasi. Types involving +//! pointer or `usize`-sized data are excluded here, so this file only contains +//! fixed-size types, so it's host/target independent. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] + +use wig::witx_wasi_types; + +witx_wasi_types!("snapshot" "wasi_snapshot_preview1"); + +pub(crate) const RIGHTS_ALL: __wasi_rights_t = __WASI_RIGHTS_FD_DATASYNC + | __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_SEEK + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_TELL + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_FD_ALLOCATE + | __WASI_RIGHTS_PATH_CREATE_DIRECTORY + | __WASI_RIGHTS_PATH_CREATE_FILE + | __WASI_RIGHTS_PATH_LINK_SOURCE + | __WASI_RIGHTS_PATH_LINK_TARGET + | __WASI_RIGHTS_PATH_OPEN + | __WASI_RIGHTS_FD_READDIR + | __WASI_RIGHTS_PATH_READLINK + | __WASI_RIGHTS_PATH_RENAME_SOURCE + | __WASI_RIGHTS_PATH_RENAME_TARGET + | __WASI_RIGHTS_PATH_FILESTAT_GET + | __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_PATH_SYMLINK + | __WASI_RIGHTS_PATH_UNLINK_FILE + | __WASI_RIGHTS_PATH_REMOVE_DIRECTORY + | __WASI_RIGHTS_POLL_FD_READWRITE + | __WASI_RIGHTS_SOCK_SHUTDOWN; + +// Block and character device interaction is outside the scope of +// WASI. Simply allow everything. +pub(crate) const RIGHTS_BLOCK_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_BLOCK_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_CHARACTER_DEVICE_BASE: __wasi_rights_t = RIGHTS_ALL; +pub(crate) const RIGHTS_CHARACTER_DEVICE_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Only allow directory operations on directories. Directories can only +// yield file descriptors to other directories and files. +pub(crate) const RIGHTS_DIRECTORY_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_PATH_CREATE_DIRECTORY + | __WASI_RIGHTS_PATH_CREATE_FILE + | __WASI_RIGHTS_PATH_LINK_SOURCE + | __WASI_RIGHTS_PATH_LINK_TARGET + | __WASI_RIGHTS_PATH_OPEN + | __WASI_RIGHTS_FD_READDIR + | __WASI_RIGHTS_PATH_READLINK + | __WASI_RIGHTS_PATH_RENAME_SOURCE + | __WASI_RIGHTS_PATH_RENAME_TARGET + | __WASI_RIGHTS_PATH_FILESTAT_GET + | __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE + | __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_PATH_SYMLINK + | __WASI_RIGHTS_PATH_UNLINK_FILE + | __WASI_RIGHTS_PATH_REMOVE_DIRECTORY + | __WASI_RIGHTS_POLL_FD_READWRITE; +pub(crate) const RIGHTS_DIRECTORY_INHERITING: __wasi_rights_t = + RIGHTS_DIRECTORY_BASE | RIGHTS_REGULAR_FILE_BASE; + +// Operations that apply to regular files. +pub(crate) const RIGHTS_REGULAR_FILE_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_DATASYNC + | __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_SEEK + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_SYNC + | __WASI_RIGHTS_FD_TELL + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_ADVISE + | __WASI_RIGHTS_FD_ALLOCATE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE + | __WASI_RIGHTS_FD_FILESTAT_SET_TIMES + | __WASI_RIGHTS_POLL_FD_READWRITE; +pub(crate) const RIGHTS_REGULAR_FILE_INHERITING: __wasi_rights_t = 0; + +// Operations that apply to sockets and socket pairs. +pub(crate) const RIGHTS_SOCKET_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_POLL_FD_READWRITE + | __WASI_RIGHTS_SOCK_SHUTDOWN; +pub(crate) const RIGHTS_SOCKET_INHERITING: __wasi_rights_t = RIGHTS_ALL; + +// Operations that apply to TTYs. +pub(crate) const RIGHTS_TTY_BASE: __wasi_rights_t = __WASI_RIGHTS_FD_READ + | __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS + | __WASI_RIGHTS_FD_WRITE + | __WASI_RIGHTS_FD_FILESTAT_GET + | __WASI_RIGHTS_POLL_FD_READWRITE; +#[allow(unused)] +pub(crate) const RIGHTS_TTY_INHERITING: __wasi_rights_t = 0; + +pub fn whence_to_str(whence: __wasi_whence_t) -> &'static str { + match whence { + __WASI_WHENCE_CUR => "__WASI_WHENCE_CUR", + __WASI_WHENCE_END => "__WASI_WHENCE_END", + __WASI_WHENCE_SET => "__WASI_WHENCE_SET", + other => panic!("Undefined whence value {:?}", other), + } +} + +pub const __WASI_DIRCOOKIE_START: __wasi_dircookie_t = 0; + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn bindgen_test_layout_wasi_dirent_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_dirent_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_next as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_next) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_namlen as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_namlen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_type as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_type) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u___wasi_event_u_fd_readwrite_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_fd_readwrite_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_event_fd_readwrite_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_fd_readwrite_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_fd_readwrite_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_fd_readwrite_t>())).nbytes as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_fd_readwrite_t), + "::", + stringify!(nbytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_fd_readwrite_t>())).flags as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_fd_readwrite_t), + "::", + stringify!(flags) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t___wasi_event_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_u_t>(), + 16usize, + concat!("Size of: ", stringify!(__wasi_event_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_u_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_event_u_t>())).fd_readwrite as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_u_t), + "::", + stringify!(fd_readwrite) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_event_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_event_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_event_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_event_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).userdata as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).error as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).r#type as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(r#type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_event_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_event_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_event_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).userdata as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).error as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_event_t>())).r#type as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(__wasi_event_t), + "::", + stringify!(r#type) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_fdstat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_fdstat_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_filetype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_flags as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_base as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_inheriting as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_inheriting) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_filestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_filestat_t>(), + 64usize, + concat!("Size of: ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).dev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).filetype as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).nlink as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).size as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).atim as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).mtim as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ctim as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ctim) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_clock_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_clock_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_subscription_clock_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_clock_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_clock_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).id as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(clock_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).timeout as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(timeout) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).precision as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(precision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_clock_t>())).flags as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_clock_t), + "::", + stringify!(flags) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u___wasi_subscription_u_fd_readwrite_t( + ) { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_fd_readwrite_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_subscription_fd_readwrite_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_fd_readwrite_t>(), + 4usize, + concat!( + "Alignment of ", + stringify!(__wasi_subscription_fd_readwrite_t) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_fd_readwrite_t>())).file_descriptor + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_fd_readwrite_t), + "::", + stringify!(fd) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t___wasi_subscription_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_u_t>(), + 32usize, + concat!("Size of: ", stringify!(__wasi_subscription_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_u_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_u_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_u_t>())).clock as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_u_t), + "::", + stringify!(clock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_u_t>())).fd_readwrite as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_u_t), + "::", + stringify!(fd_readwrite) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_subscription_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_subscription_t>(), + 48usize, + concat!("Size of: ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_subscription_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_subscription_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t>())).userdata as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(userdata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_subscription_t>())).r#type as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(r#type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_subscription_t>())).u as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_subscription_t), + "::", + stringify!(u) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_filestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_filestat_t>(), + 64usize, + concat!("Size of: ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_filestat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_filestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).dev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).filetype as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).nlink as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).size as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).atim as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).mtim as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_filestat_t>())).ctim as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(__wasi_filestat_t), + "::", + stringify!(st_ctim) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_fdstat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_fdstat_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_fdstat_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_fdstat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_filetype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_filetype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_flags as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_base as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_fdstat_t>())).fs_rights_inheriting as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_fdstat_t), + "::", + stringify!(fs_rights_inheriting) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_dirent_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_dirent_t>(), + 24usize, + concat!("Size of: ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_dirent_t>(), + 8usize, + concat!("Alignment of ", stringify!(__wasi_dirent_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_next as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_next) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_ino as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_ino) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_namlen as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_namlen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_dirent_t>())).d_type as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__wasi_dirent_t), + "::", + stringify!(d_type) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +
+//! Types and constants specific to 32-bit wasi. These are similar to the types +//! in the `host` module, but pointers and `usize` values are replaced with +//! `u32`-sized types. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(dead_code)] + +use crate::wasi::*; +use wig::witx_wasi32_types; + +pub type uintptr_t = u32; +pub type size_t = u32; + +witx_wasi32_types!("snapshot" "wasi_snapshot_preview1"); + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn bindgen_test_layout_wasi_ciovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_ciovec_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_ciovec_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_ciovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_ciovec_t>())).buf_len as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_ciovec_t), + "::", + stringify!(buf_len) + ) + ); + } + + #[test] + fn bindgen_test_layout_wasi_iovec_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_iovec_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_iovec_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_iovec_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_iovec_t>())).buf_len as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_iovec_t), + "::", + stringify!(buf_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u___wasi_prestat_u_dir_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_dir_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_dir_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_dir_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__wasi_prestat_dir_t>())).pr_name_len as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_dir_t), + "::", + stringify!(pr_name_len) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t___wasi_prestat_u() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_u_t>(), + 4usize, + concat!("Size of: ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_u_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_u_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_u_t>())).dir as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_u_t), + "::", + stringify!(dir) + ) + ); + } + + #[test] + fn bindgen_test_layout___wasi_prestat_t() { + assert_eq!( + ::std::mem::size_of::<__wasi_prestat_t>(), + 8usize, + concat!("Size of: ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + ::std::mem::align_of::<__wasi_prestat_t>(), + 4usize, + concat!("Alignment of ", stringify!(__wasi_prestat_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).pr_type as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(pr_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__wasi_prestat_t>())).u as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__wasi_prestat_t), + "::", + stringify!(u) + ) + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +
+use crate::runtime::Store; +use crate::trampoline::generate_func_export; +use crate::trap::Trap; +use crate::types::FuncType; +use crate::values::Val; +use std::ptr; +use std::rc::Rc; +use wasmtime_environ::ir; +use wasmtime_jit::InstanceHandle; +use wasmtime_runtime::Export; + +/// A trait representing a function that can be imported and called from inside +/// WebAssembly. +/// # Example +/// ``` +/// use wasmtime::Val; +/// +/// struct TimesTwo; +/// +/// impl wasmtime::Callable for TimesTwo { +/// fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), wasmtime::Trap> { +/// let mut value = params[0].unwrap_i32(); +/// value *= 2; +/// results[0] = value.into(); +/// +/// Ok(()) +/// } +/// } +/// +/// # fn main () -> Result<(), Box<dyn std::error::Error>> { +/// // Simple module that imports our host function ("times_two") and re-exports +/// // it as "run". +/// let wat = r#" +/// (module +/// (func $times_two (import "" "times_two") (param i32) (result i32)) +/// (func +/// (export "run") +/// (param i32) +/// (result i32) +/// (local.get 0) +/// (call $times_two)) +/// ) +/// "#; +/// +/// // Initialise environment and our module. +/// let store = wasmtime::Store::default(); +/// let module = wasmtime::Module::new(&store, wat)?; +/// +/// // Define the type of the function we're going to call. +/// let times_two_type = wasmtime::FuncType::new( +/// // Parameters +/// Box::new([wasmtime::ValType::I32]), +/// // Results +/// Box::new([wasmtime::ValType::I32]) +/// ); +/// +/// // Build a reference to the "times_two" function that can be used. +/// let times_two_function = +/// wasmtime::Func::new(&store, times_two_type, std::rc::Rc::new(TimesTwo)); +/// +/// // Create module instance that imports our function +/// let instance = wasmtime::Instance::new( +/// &module, +/// &[times_two_function.into()] +/// )?; +/// +/// // Get "run" function from the exports. +/// let run_function = instance.exports()[0].func().unwrap(); +/// +/// // Borrow and call "run". Returning any error message from Wasm as a string. +/// let original = 5i32; +/// let results = run_function +/// .call(&[original.into()]) +/// .map_err(|trap| trap.to_string())?; +/// +/// // Compare that the results returned matches what we expect. +/// assert_eq!(original * 2, results[0].unwrap_i32()); +/// # Ok(()) +/// # } +/// ``` +pub trait Callable { + /// What is called when the function is invoked in WebAssembly. + /// `params` is an immutable list of parameters provided to the function. + /// `results` is mutable list of results to be potentially set by your + /// function. Produces a `Trap` if the function encounters any errors. + fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap>; +} + +pub(crate) trait WrappedCallable { + fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap>; + fn signature(&self) -> &ir::Signature { + match self.wasmtime_export() { + Export::Function { signature, .. } => signature, + _ => panic!("unexpected export type in Callable"), + } + } + fn wasmtime_handle(&self) -> &InstanceHandle; + fn wasmtime_export(&self) -> &Export; +} + +pub(crate) struct WasmtimeFn { + store: Store, + instance: InstanceHandle, + export: Export, +} + +impl WasmtimeFn { + pub fn new(store: &Store, instance: InstanceHandle, export: Export) -> WasmtimeFn { + WasmtimeFn { + store: store.clone(), + instance, + export, + } + } +} + +impl WrappedCallable for WasmtimeFn { + fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> { + use std::cmp::max; + use std::mem; + + let (vmctx, body, signature) = match self.wasmtime_export() { + Export::Function { + vmctx, + address, + signature, + } => (*vmctx, *address, signature.clone()), + _ => panic!("unexpected export type in Callable"), + }; + if signature.params.len() - 2 != params.len() { + return Err(Trap::new(format!( + "expected {} arguments, got {}", + signature.params.len() - 2, + params.len() + ))); + } + if signature.returns.len() != results.len() { + return Err(Trap::new(format!( + "expected {} results, got {}", + signature.returns.len(), + results.len() + ))); + } + + let value_size = mem::size_of::<u128>(); + let mut values_vec = vec![0; max(params.len(), results.len())]; + + // Store the argument values into `values_vec`. + let param_tys = signature.params.iter().skip(2); + for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) { + if arg.ty().get_wasmtime_type() != Some(ty.value_type) { + return Err(Trap::new("argument type mismatch")); + } + unsafe { + arg.write_value_to(slot); + } + } + + // Get the trampoline to call for this function. + let exec_code_buf = self + .store + .compiler_mut() + .get_published_trampoline(&signature, value_size) + .map_err(|e| Trap::new(format!("trampoline error: {:?}", e)))?; + + // Call the trampoline. + if let Err(error) = unsafe { + wasmtime_runtime::wasmtime_call_trampoline( + vmctx, + ptr::null_mut(), + exec_code_buf, + body, + values_vec.as_mut_ptr() as *mut u8, + ) + } { + return Err(Trap::from_jit(error)); + } + + // Load the return values out of `values_vec`. + for (index, abi_param) in signature.returns.iter().enumerate() { + unsafe { + let ptr = values_vec.as_ptr().add(index); + + results[index] = Val::read_value_from(ptr, abi_param.value_type); + } + } + + Ok(()) + } + fn wasmtime_handle(&self) -> &InstanceHandle { + &self.instance + } + fn wasmtime_export(&self) -> &Export { + &self.export + } +} + +pub struct NativeCallable { + callable: Rc<dyn Callable + 'static>, + instance: InstanceHandle, + export: Export, +} + +impl NativeCallable { + pub(crate) fn new(callable: Rc<dyn Callable + 'static>, ft: &FuncType, store: &Store) -> Self { + let (instance, export) = + generate_func_export(ft, &callable, store).expect("generated func"); + NativeCallable { + callable, + instance, + export, + } + } +} + +impl WrappedCallable for NativeCallable { + fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap> { + self.callable.call(params, results) + } + fn wasmtime_handle(&self) -> &InstanceHandle { + &self.instance + } + fn wasmtime_export(&self) -> &Export { + &self.export + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +
+use crate::trampoline::{generate_global_export, generate_memory_export, generate_table_export}; +use crate::values::{from_checked_anyfunc, into_checked_anyfunc, Val}; +use crate::Mutability; +use crate::{ExternType, GlobalType, MemoryType, TableType, ValType}; +use crate::{Func, Store}; +use anyhow::{anyhow, bail, Result}; +use std::slice; +use wasmtime_environ::wasm; +use wasmtime_runtime::InstanceHandle; + +// Externals + +/// An external item to a WebAssembly module, or a list of what can possibly be +/// exported from a wasm module. +/// +/// This is both returned from [`Instance::exports`](crate::Instance::exports) +/// as well as required by [`Instance::new`](crate::Instance::new). In other +/// words, this is the type of extracted values from an instantiated module, and +/// it's also used to provide imported values when instantiating a module. +#[derive(Clone)] +pub enum Extern { + /// A WebAssembly `func` which can be called. + Func(Func), + /// A WebAssembly `global` which acts like a `Cell<T>` of sorts, supporting + /// `get` and `set` operations. + Global(Global), + /// A WebAssembly `table` which is an array of `Val` types. + Table(Table), + /// A WebAssembly linear memory. + Memory(Memory), +} + +impl Extern { + /// Returns the underlying `Func`, if this external is a function. + /// + /// Returns `None` if this is not a function. + pub fn func(&self) -> Option<&Func> { + match self { + Extern::Func(func) => Some(func), + _ => None, + } + } + + /// Returns the underlying `Global`, if this external is a global. + /// + /// Returns `None` if this is not a global. + pub fn global(&self) -> Option<&Global> { + match self { + Extern::Global(global) => Some(global), + _ => None, + } + } + + /// Returns the underlying `Table`, if this external is a table. + /// + /// Returns `None` if this is not a table. + pub fn table(&self) -> Option<&Table> { + match self { + Extern::Table(table) => Some(table), + _ => None, + } + } + + /// Returns the underlying `Memory`, if this external is a memory. + /// + /// Returns `None` if this is not a memory. + pub fn memory(&self) -> Option<&Memory> { + match self { + Extern::Memory(memory) => Some(memory), + _ => None, + } + } + + /// Returns the type associated with this `Extern`. + pub fn ty(&self) -> ExternType { + match self { + Extern::Func(ft) => ExternType::Func(ft.ty().clone()), + Extern::Memory(ft) => ExternType::Memory(ft.ty().clone()), + Extern::Table(tt) => ExternType::Table(tt.ty().clone()), + Extern::Global(gt) => ExternType::Global(gt.ty().clone()), + } + } + + pub(crate) fn get_wasmtime_export(&self) -> wasmtime_runtime::Export { + match self { + Extern::Func(f) => f.wasmtime_export().clone(), + Extern::Global(g) => g.wasmtime_export().clone(), + Extern::Memory(m) => m.wasmtime_export().clone(), + Extern::Table(t) => t.wasmtime_export().clone(), + } + } + + pub(crate) fn from_wasmtime_export( + store: &Store, + instance_handle: InstanceHandle, + export: wasmtime_runtime::Export, + ) -> Extern { + match export { + wasmtime_runtime::Export::Function { .. } => { + Extern::Func(Func::from_wasmtime_function(export, store, instance_handle)) + } + wasmtime_runtime::Export::Memory { .. } => { + Extern::Memory(Memory::from_wasmtime_memory(export, store, instance_handle)) + } + wasmtime_runtime::Export::Global { .. } => { + Extern::Global(Global::from_wasmtime_global(export, store, instance_handle)) + } + wasmtime_runtime::Export::Table { .. } => { + Extern::Table(Table::from_wasmtime_table(export, store, instance_handle)) + } + } + } +} + +impl From<Func> for Extern { + fn from(r: Func) -> Self { + Extern::Func(r) + } +} + +impl From<Global> for Extern { + fn from(r: Global) -> Self { + Extern::Global(r) + } +} + +impl From<Memory> for Extern { + fn from(r: Memory) -> Self { + Extern::Memory(r) + } +} + +impl From<Table> for Extern { + fn from(r: Table) -> Self { + Extern::Table(r) + } +} + +/// A WebAssembly `global` value which can be read and written to. +/// +/// A `global` in WebAssembly is sort of like a global variable within an +/// [`Instance`](crate::Instance). The `global.get` and `global.set` +/// instructions will modify and read global values in a wasm module. Globals +/// can either be imported or exported from wasm modules. +/// +/// If you're familiar with Rust already you can think of a `Global` as a sort +/// of `Rc<Cell<Val>>`, more or less. +/// +/// # `Global` and `Clone` +/// +/// Globals are internally reference counted so you can `clone` a `Global`. The +/// cloning process only performs a shallow clone, so two cloned `Global` +/// instances are equivalent in their functionality. +#[derive(Clone)] +pub struct Global { + _store: Store, + ty: GlobalType, + wasmtime_export: wasmtime_runtime::Export, + wasmtime_handle: InstanceHandle, +} + +impl Global { + /// Creates a new WebAssembly `global` value with the provide type `ty` and + /// initial value `val`. + /// + /// The `store` argument provided is used as a general global cache for + /// information, and otherwise the `ty` and `val` arguments are used to + /// initialize the global. + /// + /// # Errors + /// + /// Returns an error if the `ty` provided does not match the type of the + /// value `val`. + pub fn new(store: &Store, ty: GlobalType, val: Val) -> Result<Global> { + if val.ty() != *ty.content() { + bail!("value provided does not match the type of this global"); + } + let (wasmtime_handle, wasmtime_export) = generate_global_export(store, &ty, val)?; + Ok(Global { + _store: store.clone(), + ty, + wasmtime_export, + wasmtime_handle, + }) + } + + /// Returns the underlying type of this `global`. + pub fn ty(&self) -> &GlobalType { + &self.ty + } + + fn wasmtime_global_definition(&self) -> *mut wasmtime_runtime::VMGlobalDefinition { + match self.wasmtime_export { + wasmtime_runtime::Export::Global { definition, .. } => definition, + _ => panic!("global definition not found"), + } + } + + /// Returns the current [`Val`] of this global. + pub fn get(&self) -> Val { + let definition = unsafe { &mut *self.wasmtime_global_definition() }; + unsafe { + match self.ty().content() { + ValType::I32 => Val::from(*definition.as_i32()), + ValType::I64 => Val::from(*definition.as_i64()), + ValType::F32 => Val::F32(*definition.as_u32()), + ValType::F64 => Val::F64(*definition.as_u64()), + _ => unimplemented!("Global::get for {:?}", self.ty().content()), + } + } + } + + /// Attempts to set the current value of this global to [`Val`]. + /// + /// # Errors + /// + /// Returns an error if this global has a different type than `Val`, or if + /// it's not a mutable global. + pub fn set(&self, val: Val) -> Result<()> { + if self.ty().mutability() != Mutability::Var { + bail!("immutable global cannot be set"); + } + if val.ty() != *self.ty().content() { + bail!( + "global of type {:?} cannot be set to {:?}", + self.ty().content(), + val.ty() + ); + } + let definition = unsafe { &mut *self.wasmtime_global_definition() }; + unsafe { + match val { + Val::I32(i) => *definition.as_i32_mut() = i, + Val::I64(i) => *definition.as_i64_mut() = i, + Val::F32(f) => *definition.as_u32_mut() = f, + Val::F64(f) => *definition.as_u64_mut() = f, + _ => unimplemented!("Global::set for {:?}", val.ty()), + } + } + Ok(()) + } + + pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export { + &self.wasmtime_export + } + + pub(crate) fn from_wasmtime_global( + export: wasmtime_runtime::Export, + store: &Store, + wasmtime_handle: InstanceHandle, + ) -> Global { + let global = if let wasmtime_runtime::Export::Global { ref global, .. } = export { + global + } else { + panic!("wasmtime export is not global") + }; + // The original export is coming from wasmtime_runtime itself we should + // support all the types coming out of it, so assert such here. + let ty = GlobalType::from_wasmtime_global(&global) + .expect("core wasm global type should be supported"); + Global { + _store: store.clone(), + ty: ty, + wasmtime_export: export, + wasmtime_handle, + } + } +} + +/// A WebAssembly `table`, or an array of values. +/// +/// Like [`Memory`] a table is an indexed array of values, but unlike [`Memory`] +/// it's an array of WebAssembly values rather than bytes. One of the most +/// common usages of a table is a function table for wasm modules, where each +/// element has the `Func` type. +/// +/// Tables, like globals, are not threadsafe and can only be used on one thread. +/// Tables can be grown in size and each element can be read/written. +/// +/// # `Table` and `Clone` +/// +/// Tables are internally reference counted so you can `clone` a `Table`. The +/// cloning process only performs a shallow clone, so two cloned `Table` +/// instances are equivalent in their functionality. +#[derive(Clone)] +pub struct Table { + store: Store, + ty: TableType, + wasmtime_handle: InstanceHandle, + wasmtime_export: wasmtime_runtime::Export, +} + +fn set_table_item( + handle: &mut InstanceHandle, + table_index: wasm::DefinedTableIndex, + item_index: u32, + item: wasmtime_runtime::VMCallerCheckedAnyfunc, +) -> Result<()> { + handle + .table_set(table_index, item_index, item) + .map_err(|()| anyhow!("table element index out of bounds")) +} + +impl Table { + /// Creates a new `Table` with the given parameters. + /// + /// * `store` - a global cache to store information in + /// * `ty` - the type of this table, containing both the element type as + /// well as the initial size and maximum size, if any. + /// * `init` - the initial value to fill all table entries with, if the + /// table starts with an initial size. + /// + /// # Errors + /// + /// Returns an error if `init` does not match the element type of the table. + pub fn new(store: &Store, ty: TableType, init: Val) -> Result<Table> { + let item = into_checked_anyfunc(init, store)?; + let (mut wasmtime_handle, wasmtime_export) = generate_table_export(store, &ty)?; + + // Initialize entries with the init value. + match wasmtime_export { + wasmtime_runtime::Export::Table { definition, .. } => { + let index = wasmtime_handle.table_index(unsafe { &*definition }); + let len = unsafe { (*definition).current_elements }; + for i in 0..len { + set_table_item(&mut wasmtime_handle, index, i, item.clone())?; + } + } + _ => unreachable!("export should be a table"), + } + + Ok(Table { + store: store.clone(), + ty, + wasmtime_handle, + wasmtime_export, + }) + } + + /// Returns the underlying type of this table, including its element type as + /// well as the maximum/minimum lower bounds. + pub fn ty(&self) -> &TableType { + &self.ty + } + + fn wasmtime_table_index(&self) -> wasm::DefinedTableIndex { + match self.wasmtime_export { + wasmtime_runtime::Export::Table { definition, .. } => { + self.wasmtime_handle.table_index(unsafe { &*definition }) + } + _ => panic!("global definition not found"), + } + } + + /// Returns the table element value at `index`. + /// + /// Returns `None` if `index` is out of bounds. + pub fn get(&self, index: u32) -> Option<Val> { + let table_index = self.wasmtime_table_index(); + let item = self.wasmtime_handle.table_get(table_index, index)?; + Some(from_checked_anyfunc(item, &self.store)) + } + + /// Writes the `val` provided into `index` within this table. + /// + /// # Errors + /// + /// Returns an error if `index` is out of bounds or if `val` does not have + /// the right type to be stored in this table. + pub fn set(&self, index: u32, val: Val) -> Result<()> { + let table_index = self.wasmtime_table_index(); + let mut wasmtime_handle = self.wasmtime_handle.clone(); + let item = into_checked_anyfunc(val, &self.store)?; + set_table_item(&mut wasmtime_handle, table_index, index, item) + } + + /// Returns the current size of this table. + pub fn size(&self) -> u32 { + match self.wasmtime_export { + wasmtime_runtime::Export::Table { definition, .. } => unsafe { + (*definition).current_elements + }, + _ => panic!("global definition not found"), + } + } + + /// Grows the size of this table by `delta` more elements, initialization + /// all new elements to `init`. + /// + /// # Errors + /// + /// Returns an error if the table cannot be grown by `delta`, for example + /// if it would cause the table to exceed its maximum size. Also returns an + /// error if `init` is not of the right type. + pub fn grow(&self, delta: u32, init: Val) -> Result<u32> { + let index = self.wasmtime_table_index(); + let item = into_checked_anyfunc(init, &self.store)?; + if let Some(len) = self.wasmtime_handle.clone().table_grow(index, delta) { + let mut wasmtime_handle = self.wasmtime_handle.clone(); + for i in 0..delta { + let i = len - (delta - i); + set_table_item(&mut wasmtime_handle, index, i, item.clone())?; + } + Ok(len) + } else { + bail!("failed to grow table by `{}`", delta) + } + } + + pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export { + &self.wasmtime_export + } + + pub(crate) fn from_wasmtime_table( + export: wasmtime_runtime::Export, + store: &Store, + instance_handle: wasmtime_runtime::InstanceHandle, + ) -> Table { + let table = if let wasmtime_runtime::Export::Table { ref table, .. } = export { + table + } else { + panic!("wasmtime export is not table") + }; + let ty = TableType::from_wasmtime_table(&table.table); + Table { + store: store.clone(), + ty: ty, + wasmtime_handle: instance_handle, + wasmtime_export: export, + } + } +} + +/// A WebAssembly linear memory. +/// +/// WebAssembly memories represent a contiguous array of bytes that have a size +/// that is always a multiple of the WebAssembly page size, currently 64 +/// kilobytes. +/// +/// WebAssembly memory is used for global data, statics in C/C++/Rust, shadow +/// stack memory, etc. Accessing wasm memory is generally quite fast! +/// +/// # `Memory` and `Clone` +/// +/// Memories are internally reference counted so you can `clone` a `Memory`. The +/// cloning process only performs a shallow clone, so two cloned `Memory` +/// instances are equivalent in their functionality. +/// +/// # `Memory` and threads +/// +/// It is intended that `Memory` is safe to share between threads. At this time +/// this is not implemented in `wasmtime`, however. This is planned to be +/// implemented though! +#[derive(Clone)] +pub struct Memory { + _store: Store, + ty: MemoryType, + wasmtime_handle: InstanceHandle, + wasmtime_export: wasmtime_runtime::Export, +} + +impl Memory { + /// Creates a new WebAssembly memory given the configuration of `ty`. + /// + /// The `store` argument is a general location for cache information, and + /// otherwise the memory will immediately be allocated according to the + /// type's configuration. All WebAssembly memory is initialized to zero. + pub fn new(store: &Store, ty: MemoryType) -> Memory { + let (wasmtime_handle, wasmtime_export) = + generate_memory_export(store, &ty).expect("generated memory"); + Memory { + _store: store.clone(), + ty, + wasmtime_handle, + wasmtime_export, + } + } + + /// Returns the underlying type of this memory. + pub fn ty(&self) -> &MemoryType { + &self.ty + } + + fn wasmtime_memory_definition(&self) -> *mut wasmtime_runtime::VMMemoryDefinition { + match self.wasmtime_export { + wasmtime_runtime::Export::Memory { definition, .. } => definition, + _ => panic!("memory definition not found"), + } + } + + /// Returns this memory as a slice view that can be read natively in Rust. + /// + /// # Safety + /// + /// This is an unsafe operation because there is no guarantee that the + /// following operations do not happen concurrently while the slice is in + /// use: + /// + /// * Data could be modified by calling into a wasm module. + /// * Memory could be relocated through growth by calling into a wasm + /// module. + /// * When threads are supported, non-atomic reads will race with other + /// writes. + /// + /// Extreme care need be taken when the data of a `Memory` is read. The + /// above invariants all need to be upheld at a bare minimum, and in + /// general you'll need to ensure that while you're looking at slice you're + /// the only one who can possibly look at the slice and read/write it. + /// + /// Be sure to keep in mind that `Memory` is reference counted, meaning + /// that there may be other users of this `Memory` instance elsewhere in + /// your program. Additionally `Memory` can be shared and used in any number + /// of wasm instances, so calling any wasm code should be considered + /// dangerous while you're holding a slice of memory. + pub unsafe fn data_unchecked(&self) -> &[u8] { + self.data_unchecked_mut() + } + + /// Returns this memory as a slice view that can be read and written + /// natively in Rust. + /// + /// # Safety + /// + /// All of the same safety caveats of [`Memory::data_unchecked`] apply + /// here, doubly so because this is returning a mutable slice! As a + /// double-extra reminder, remember that `Memory` is reference counted, so + /// you can very easily acquire two mutable slices by simply calling this + /// function twice. Extreme caution should be used when using this method, + /// and in general you probably want to result to unsafe accessors and the + /// `data` methods below. + pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] { + let definition = &*self.wasmtime_memory_definition(); + slice::from_raw_parts_mut(definition.base, definition.current_length) + } + + /// Returns the base pointer, in the host's address space, that the memory + /// is located at. + /// + /// When reading and manipulating memory be sure to read up on the caveats + /// of [`Memory::data_unchecked`] to make sure that you can safely + /// read/write the memory. + pub fn data_ptr(&self) -> *mut u8 { + unsafe { (*self.wasmtime_memory_definition()).base } + } + + /// Returns the byte length of this memory. + /// + /// The returned value will be a multiple of the wasm page size, 64k. + pub fn data_size(&self) -> usize { + unsafe { (*self.wasmtime_memory_definition()).current_length } + } + + /// Returns the size, in pages, of this wasm memory. + pub fn size(&self) -> u32 { + (self.data_size() / wasmtime_environ::WASM_PAGE_SIZE as usize) as u32 + } + + /// Grows this WebAssembly memory by `delta` pages. + /// + /// This will attempt to add `delta` more pages of memory on to the end of + /// this `Memory` instance. If successful this may relocate the memory and + /// cause [`Memory::data_ptr`] to return a new value. Additionally previous + /// slices into this memory may no longer be valid. + /// + /// On success returns the number of pages this memory previously had + /// before the growth succeeded. + /// + /// # Errors + /// + /// Returns an error if memory could not be grown, for example if it exceeds + /// the maximum limits of this memory. + pub fn grow(&self, delta: u32) -> Result<u32> { + match self.wasmtime_export { + wasmtime_runtime::Export::Memory { definition, .. } => { + let definition = unsafe { &(*definition) }; + let index = self.wasmtime_handle.memory_index(definition); + self.wasmtime_handle + .clone() + .memory_grow(index, delta) + .ok_or_else(|| anyhow!("failed to grow memory")) + } + _ => panic!("memory definition not found"), + } + } + + pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export { + &self.wasmtime_export + } + + pub(crate) fn from_wasmtime_memory( + export: wasmtime_runtime::Export, + store: &Store, + instance_handle: wasmtime_runtime::InstanceHandle, + ) -> Memory { + let memory = if let wasmtime_runtime::Export::Memory { ref memory, .. } = export { + memory + } else { + panic!("wasmtime export is not memory") + }; + let ty = MemoryType::from_wasmtime_memory(&memory.memory); + Memory { + _store: store.clone(), + ty: ty, + wasmtime_handle: instance_handle, + wasmtime_export: export, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +
+use crate::module::Names; +use std::collections::BTreeMap; +use std::sync::{Arc, RwLock}; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::wasm::FuncIndex; +use wasmtime_jit::CompiledModule; + +lazy_static::lazy_static! { + /// This is a global cache of backtrace frame information for all active + /// + /// This global cache is used during `Trap` creation to symbolicate frames. + /// This is populated on module compilation, and it is cleared out whenever + /// all references to a module are dropped. + pub static ref FRAME_INFO: GlobalFrameInfo = GlobalFrameInfo::default(); +} + +#[derive(Default)] +pub struct GlobalFrameInfo { + /// An internal map that keeps track of backtrace frame information for + /// each module. + /// + /// This map is morally a map of ranges to a map of information for that + /// module. Each module is expected to reside in a disjoint section of + /// contiguous memory. No modules can overlap. + /// + /// The key of this map is the highest address in the module and the value + /// is the module's information, which also contains the start address. + ranges: RwLock<BTreeMap<usize, ModuleFrameInfo>>, +} + +/// An RAII structure used to unregister a module's frame information when the +/// module is destroyed. +pub struct GlobalFrameInfoRegistration { + /// The key that will be removed from the global `ranges` map when this is + /// dropped. + key: usize, +} + +struct ModuleFrameInfo { + start: usize, + functions: BTreeMap<usize, (usize, FuncIndex)>, + names: Arc<Names>, +} + +impl GlobalFrameInfo { + /// Registers a new compiled module's frame information. + /// + /// This function will register the `names` information for all of the + /// compiled functions within `module`. If the `module` has no functions + /// then `None` will be returned. Otherwise the returned object, when + /// dropped, will be used to unregister all name information from this map. + pub fn register( + &self, + names: &Arc<Names>, + module: &CompiledModule, + ) -> Option<GlobalFrameInfoRegistration> { + let mut min = usize::max_value(); + let mut max = 0; + let mut functions = BTreeMap::new(); + for (i, allocated) in module.finished_functions() { + let (start, end) = unsafe { + let ptr = (**allocated).as_ptr(); + let len = (**allocated).len(); + (ptr as usize, ptr as usize + len) + }; + if start < min { + min = start; + } + if end > max { + max = end; + } + let func_index = module.module().func_index(i); + assert!(functions.insert(end, (start, func_index)).is_none()); + } + if functions.len() == 0 { + return None; + } + + let mut ranges = self.ranges.write().unwrap(); + // First up assert that our chunk of jit functions doesn't collide with + // any other known chunks of jit functions... + if let Some((_, prev)) = ranges.range(max..).next() { + assert!(prev.start > max); + } + if let Some((prev_end, _)) = ranges.range(..=min).next_back() { + assert!(*prev_end < min); + } + + // ... then insert our range and assert nothing was there previously + let prev = ranges.insert( + max, + ModuleFrameInfo { + start: min, + functions, + names: names.clone(), + }, + ); + assert!(prev.is_none()); + Some(GlobalFrameInfoRegistration { key: max }) + } + + /// Fetches information about a program counter in a backtrace. + /// + /// Returns an object if this `pc` is known to some previously registered + /// module, or returns `None` if no information can be found. + pub fn lookup(&self, pc: usize) -> Option<FrameInfo> { + let ranges = self.ranges.read().ok()?; + let (end, info) = ranges.range(pc..).next()?; + if pc < info.start || *end < pc { + return None; + } + let (end, (start, func_index)) = info.functions.range(pc..).next()?; + if pc < *start || *end < pc { + return None; + } + Some(FrameInfo { + module_name: info.names.module_name.clone(), + func_index: func_index.index() as u32, + func_name: info.names.module.func_names.get(func_index).cloned(), + }) + } +} + +impl Drop for GlobalFrameInfoRegistration { + fn drop(&mut self) { + if let Ok(mut map) = FRAME_INFO.ranges.write() { + map.remove(&self.key); + } + } +} + +/// Description of a frame in a backtrace for a [`Trap`]. +/// +/// Whenever a WebAssembly trap occurs an instance of [`Trap`] is created. Each +/// [`Trap`] has a backtrace of the WebAssembly frames that led to the trap, and +/// each frame is described by this structure. +#[derive(Debug)] +pub struct FrameInfo { + module_name: Option<String>, + func_index: u32, + func_name: Option<String>, +} + +impl FrameInfo { + /// Returns the WebAssembly function index for this frame. + /// + /// This function index is the index in the function index space of the + /// WebAssembly module that this frame comes from. + pub fn func_index(&self) -> u32 { + self.func_index + } + + /// Returns the identifer of the module that this frame is for. + /// + /// Module identifiers are present in the `name` section of a WebAssembly + /// binary, but this may not return the exact item in the `name` section. + /// Module names can be overwritten at construction time or perhaps inferred + /// from file names. The primary purpose of this function is to assist in + /// debugging and therefore may be tweaked over time. + /// + /// This function returns `None` when no name can be found or inferred. + pub fn module_name(&self) -> Option<&str> { + self.module_name.as_deref() + } + + /// Returns a descriptive name of the function for this frame, if one is + /// available. + /// + /// The name of this function may come from the `name` section of the + /// WebAssembly binary, or wasmtime may try to infer a better name for it if + /// not available, for example the name of the export if it's exported. + /// + /// This return value is primarily used for debugging and human-readable + /// purposes for things like traps. Note that the exact return value may be + /// tweaked over time here and isn't guaranteed to be something in + /// particular about a wasm module due to its primary purpose of assisting + /// in debugging. + /// + /// This function returns `None` when no name could be inferred. + pub fn func_name(&self) -> Option<&str> { + self.func_name.as_deref() + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +
+use crate::callable::{NativeCallable, WasmtimeFn, WrappedCallable}; +use crate::{Callable, FuncType, Store, Trap, Val, ValType}; +use std::fmt; +use std::mem; +use std::panic::{self, AssertUnwindSafe}; +use std::ptr; +use std::rc::Rc; +use wasmtime_jit::InstanceHandle; +use wasmtime_runtime::{VMContext, VMFunctionBody}; + +/// A WebAssembly function which can be called. +/// +/// This type can represent a number of callable items, such as: +/// +/// * An exported function from a WebAssembly module. +/// * A user-defined function used to satisfy an import. +/// +/// These types of callable items are all wrapped up in this `Func` and can be +/// used to both instantiate an [`Instance`](crate::Instance) as well as be +/// extracted from an [`Instance`](crate::Instance). +/// +/// # `Func` and `Clone` +/// +/// Functions are internally reference counted so you can `clone` a `Func`. The +/// cloning process only performs a shallow clone, so two cloned `Func` +/// instances are equivalent in their functionality. +#[derive(Clone)] +pub struct Func { + _store: Store, + callable: Rc<dyn WrappedCallable + 'static>, + ty: FuncType, +} + +macro_rules! wrappers { + ($( + $(#[$doc:meta])* + ($name:ident $(,$args:ident)*) + )*) => ($( + $(#[$doc])* + pub fn $name<F, $($args,)* R>(store: &Store, func: F) -> Func + where + F: Fn($($args),*) -> R + 'static, + $($args: WasmTy,)* + R: WasmRet, + { + #[allow(non_snake_case)] + unsafe extern "C" fn shim<F, $($args,)* R>( + vmctx: *mut VMContext, + _caller_vmctx: *mut VMContext, + $($args: $args::Abi,)* + ) -> R::Abi + where + F: Fn($($args),*) -> R + 'static, + $($args: WasmTy,)* + R: WasmRet, + { + let ret = { + let instance = InstanceHandle::from_vmctx(vmctx); + let func = instance.host_state().downcast_ref::<F>().expect("state"); + panic::catch_unwind(AssertUnwindSafe(|| { + func($($args::from_abi(_caller_vmctx, $args)),*) + })) + }; + match ret { + Ok(ret) => ret.into_abi(), + Err(panic) => wasmtime_runtime::resume_panic(panic), + } + } + + let mut _args = Vec::new(); + $($args::push(&mut _args);)* + let mut ret = Vec::new(); + R::push(&mut ret); + let ty = FuncType::new(_args.into(), ret.into()); + unsafe { + let (instance, export) = crate::trampoline::generate_raw_func_export( + &ty, + std::slice::from_raw_parts_mut( + shim::<F, $($args,)* R> as *mut _, + 0, + ), + store, + Box::new(func), + ) + .expect("failed to generate export"); + let callable = Rc::new(WasmtimeFn::new(store, instance, export)); + Func::from_wrapped(store, ty, callable) + } + } + )*) +} + +macro_rules! getters { + ($( + $(#[$doc:meta])* + ($name:ident $(,$args:ident)*) + )*) => ($( + $(#[$doc])* + #[allow(non_snake_case)] + pub fn $name<$($args,)* R>(&self) + -> Option<impl Fn($($args,)*) -> Result<R, Trap>> + where + $($args: WasmTy,)* + R: WasmTy, + { + // Verify all the paramers match the expected parameters, and that + // there are no extra parameters... + let mut params = self.ty().params().iter().cloned(); + $( + if !$args::matches(&mut params) { + return None; + } + )* + if !params.next().is_none() { + return None; + } + + // ... then do the same for the results... + let mut results = self.ty().results().iter().cloned(); + if !R::matches(&mut results) { + return None; + } + if !results.next().is_none() { + return None; + } + + // ... and then once we've passed the typechecks we can hand out our + // object since our `transmute` below should be safe! + let (address, vmctx) = match self.wasmtime_export() { + wasmtime_runtime::Export::Function { address, vmctx, signature: _} => { + (*address, *vmctx) + } + _ => return None, + }; + Some(move |$($args: $args),*| -> Result<R, Trap> { + unsafe { + let f = mem::transmute::< + *const VMFunctionBody, + unsafe extern "C" fn( + *mut VMContext, + *mut VMContext, + $($args::Abi,)* + ) -> R::Abi, + >(address); + let mut ret = None; + $(let $args = $args.into_abi();)* + wasmtime_runtime::catch_traps(vmctx, || { + ret = Some(f(vmctx, ptr::null_mut(), $($args,)*)); + }).map_err(Trap::from_jit)?; + Ok(R::from_abi(vmctx, ret.unwrap())) + } + }) + } + )*) +} + +impl Func { + /// Creates a new `Func` with the given arguments, typically to create a + /// user-defined function to pass as an import to a module. + /// + /// * `store` - a cache of data where information is stored, typically + /// shared with a [`Module`](crate::Module). + /// + /// * `ty` - the signature of this function, used to indicate what the + /// inputs and outputs are, which must be WebAssembly types. + /// + /// * `callable` - a type implementing the [`Callable`] trait which + /// is the implementation of this `Func` value. + /// + /// Note that the implementation of `callable` must adhere to the `ty` + /// signature given, error or traps may occur if it does not respect the + /// `ty` signature. + pub fn new(store: &Store, ty: FuncType, callable: Rc<dyn Callable + 'static>) -> Self { + let callable = Rc::new(NativeCallable::new(callable, &ty, &store)); + Func::from_wrapped(store, ty, callable) + } + + wrappers! { + /// Creates a new `Func` from the given Rust closure, which takes 0 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap0) + + /// Creates a new `Func` from the given Rust closure, which takes 1 + /// argument. + /// + /// This function will create a new `Func` which, when called, will + /// execute the given Rust closure. Unlike [`Func::new`] the target + /// function being called is known statically so the type signature can + /// be inferred. Rust types will map to WebAssembly types as follows: + /// + /// + /// | Rust Argument Type | WebAssembly Type | + /// |--------------------|------------------| + /// | `i32` | `i32` | + /// | `i64` | `i64` | + /// | `f32` | `f32` | + /// | `f64` | `f64` | + /// | (not supported) | `v128` | + /// | (not supported) | `anyref` | + /// + /// Any of the Rust types can be returned from the closure as well, in + /// addition to some extra types + /// + /// | Rust Return Type | WebAssembly Return Type | Meaning | + /// |-------------------|-------------------------|-------------------| + /// | `()` | nothing | no return value | + /// | `Result<T, Trap>` | `T` | function may trap | + /// + /// Note that when using this API (and the related `wrap*` family of + /// functions), the intention is to create as thin of a layer as + /// possible for when WebAssembly calls the function provided. With + /// sufficient inlining and optimization the WebAssembly will call + /// straight into `func` provided, with no extra fluff entailed. + (wrap1, A) + + /// Creates a new `Func` from the given Rust closure, which takes 2 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap2, A, B) + + /// Creates a new `Func` from the given Rust closure, which takes 3 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap3, A, B, C) + + /// Creates a new `Func` from the given Rust closure, which takes 4 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap4, A, B, C, D) + + /// Creates a new `Func` from the given Rust closure, which takes 5 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap5, A, B, C, D, E) + + /// Creates a new `Func` from the given Rust closure, which takes 6 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap6, A, B, C, D, E, G) + + /// Creates a new `Func` from the given Rust closure, which takes 7 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap7, A, B, C, D, E, G, H) + + /// Creates a new `Func` from the given Rust closure, which takes 8 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap8, A, B, C, D, E, G, H, I) + + /// Creates a new `Func` from the given Rust closure, which takes 9 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap9, A, B, C, D, E, G, H, I, J) + + /// Creates a new `Func` from the given Rust closure, which takes 10 + /// arguments. + /// + /// For more information about this function, see [`Func::wrap1`]. + (wrap10, A, B, C, D, E, G, H, I, J, K) + } + + fn from_wrapped( + store: &Store, + ty: FuncType, + callable: Rc<dyn WrappedCallable + 'static>, + ) -> Func { + Func { + _store: store.clone(), + callable, + ty, + } + } + + /// Returns the underlying wasm type that this `Func` has. + pub fn ty(&self) -> &FuncType { + &self.ty + } + + /// Returns the number of parameters that this function takes. + pub fn param_arity(&self) -> usize { + self.ty.params().len() + } + + /// Returns the number of results this function produces. + pub fn result_arity(&self) -> usize { + self.ty.results().len() + } + + /// Invokes this function with the `params` given, returning the results and + /// any trap, if one occurs. + /// + /// The `params` here must match the type signature of this `Func`, or a + /// trap will occur. If a trap occurs while executing this function, then a + /// trap will also be returned. + /// + /// This function should not panic unless the underlying function itself + /// initiates a panic. + pub fn call(&self, params: &[Val]) -> Result<Box<[Val]>, Trap> { + let mut results = vec![Val::null(); self.result_arity()]; + self.callable.call(params, &mut results)?; + Ok(results.into_boxed_slice()) + } + + pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export { + self.callable.wasmtime_export() + } + + pub(crate) fn from_wasmtime_function( + export: wasmtime_runtime::Export, + store: &Store, + instance_handle: InstanceHandle, + ) -> Self { + // This is only called with `Export::Function`, and since it's coming + // from wasmtime_runtime itself we should support all the types coming + // out of it, so assert such here. + let ty = if let wasmtime_runtime::Export::Function { signature, .. } = &export { + FuncType::from_wasmtime_signature(signature.clone()) + .expect("core wasm signature should be supported") + } else { + panic!("expected function export") + }; + let callable = WasmtimeFn::new(store, instance_handle, export); + Func::from_wrapped(store, ty, Rc::new(callable)) + } + + getters! { + /// Extracts a natively-callable object from this `Func`, if the + /// signature matches. + /// + /// See the [`Func::get1`] method for more documentation. + (get0) + + /// Extracts a natively-callable object from this `Func`, if the + /// signature matches. + /// + /// This function serves as an optimized version of the [`Func::call`] + /// method if the type signature of a function is statically known to + /// the program. This method is faster than `call` on a few metrics: + /// + /// * Runtime type-checking only happens once, when this method is + /// called. + /// * The result values, if any, aren't boxed into a vector. + /// * Arguments and return values don't go through boxing and unboxing. + /// * No trampolines are used to transfer control flow to/from JIT code, + /// instead this function jumps directly into JIT code. + /// + /// For more information about which Rust types match up to which wasm + /// types, see the documentation on [`Func::wrap1`]. + /// + /// # Return + /// + /// This function will return `None` if the type signature asserted + /// statically does not match the runtime type signature. `Some`, + /// however, will be returned if the underlying function takes one + /// parameter of type `A` and returns the parameter `R`. Currently `R` + /// can either be `()` (no return values) or one wasm type. At this time + /// a multi-value return isn't supported. + /// + /// The returned closure will always return a `Result<R, Trap>` and an + /// `Err` is returned if a trap happens while the wasm is executing. + (get1, A) + + /// Extracts a natively-callable object from this `Func`, if the + /// signature matches. + /// + /// See the [`Func::get1`] method for more documentation. + (get2, A, B) + } +} + +impl fmt::Debug for Func { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Func") + } +} + +/// A trait implemented for types which can be arguments to closures passed to +/// [`Func::wrap1`] and friends. +/// +/// This trait should not be implemented by user types. This trait may change at +/// any time internally. The types which implement this trait, however, are +/// stable over time. +/// +/// For more information see [`Func::wrap1`] +pub trait WasmTy { + #[doc(hidden)] + type Abi: Copy; + #[doc(hidden)] + fn push(dst: &mut Vec<ValType>); + #[doc(hidden)] + fn matches(tys: impl Iterator<Item = ValType>) -> bool; + #[doc(hidden)] + fn from_abi(vmctx: *mut VMContext, abi: Self::Abi) -> Self; + #[doc(hidden)] + fn into_abi(self) -> Self::Abi; +} + +impl WasmTy for () { + type Abi = (); + fn push(_dst: &mut Vec<ValType>) {} + fn matches(_tys: impl Iterator<Item = ValType>) -> bool { + true + } + #[inline] + fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self { + abi + } + #[inline] + fn into_abi(self) -> Self::Abi { + self + } +} + +impl WasmTy for i32 { + type Abi = Self; + fn push(dst: &mut Vec<ValType>) { + dst.push(ValType::I32); + } + fn matches(mut tys: impl Iterator<Item = ValType>) -> bool { + tys.next() == Some(ValType::I32) + } + #[inline] + fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self { + abi + } + #[inline] + fn into_abi(self) -> Self::Abi { + self + } +} + +impl WasmTy for i64 { + type Abi = Self; + fn push(dst: &mut Vec<ValType>) { + dst.push(ValType::I64); + } + fn matches(mut tys: impl Iterator<Item = ValType>) -> bool { + tys.next() == Some(ValType::I64) + } + #[inline] + fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self { + abi + } + #[inline] + fn into_abi(self) -> Self::Abi { + self + } +} + +impl WasmTy for f32 { + type Abi = Self; + fn push(dst: &mut Vec<ValType>) { + dst.push(ValType::F32); + } + fn matches(mut tys: impl Iterator<Item = ValType>) -> bool { + tys.next() == Some(ValType::F32) + } + #[inline] + fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self { + abi + } + #[inline] + fn into_abi(self) -> Self::Abi { + self + } +} + +impl WasmTy for f64 { + type Abi = Self; + fn push(dst: &mut Vec<ValType>) { + dst.push(ValType::F64); + } + fn matches(mut tys: impl Iterator<Item = ValType>) -> bool { + tys.next() == Some(ValType::F64) + } + #[inline] + fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self { + abi + } + #[inline] + fn into_abi(self) -> Self::Abi { + self + } +} + +/// A trait implemented for types which can be returned from closures passed to +/// [`Func::wrap1`] and friends. +/// +/// This trait should not be implemented by user types. This trait may change at +/// any time internally. The types which implement this trait, however, are +/// stable over time. +/// +/// For more information see [`Func::wrap1`] +pub trait WasmRet { + #[doc(hidden)] + type Abi; + #[doc(hidden)] + fn push(dst: &mut Vec<ValType>); + #[doc(hidden)] + fn matches(tys: impl Iterator<Item = ValType>) -> bool; + #[doc(hidden)] + fn into_abi(self) -> Self::Abi; +} + +impl<T: WasmTy> WasmRet for T { + type Abi = T::Abi; + fn push(dst: &mut Vec<ValType>) { + T::push(dst) + } + + fn matches(tys: impl Iterator<Item = ValType>) -> bool { + T::matches(tys) + } + + #[inline] + fn into_abi(self) -> Self::Abi { + T::into_abi(self) + } +} + +impl<T: WasmTy> WasmRet for Result<T, Trap> { + type Abi = T::Abi; + fn push(dst: &mut Vec<ValType>) { + T::push(dst) + } + + fn matches(tys: impl Iterator<Item = ValType>) -> bool { + T::matches(tys) + } + + #[inline] + fn into_abi(self) -> Self::Abi { + match self { + Ok(val) => return val.into_abi(), + Err(trap) => handle_trap(trap), + } + + fn handle_trap(trap: Trap) -> ! { + unsafe { wasmtime_runtime::raise_user_trap(Box::new(trap)) } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +
+use crate::externals::Extern; +use crate::module::Module; +use crate::runtime::Store; +use crate::trap::Trap; +use anyhow::{Error, Result}; +use wasmtime_jit::{CompiledModule, Resolver}; +use wasmtime_runtime::{Export, InstanceHandle, InstantiationError}; + +struct SimpleResolver<'a> { + imports: &'a [Extern], +} + +impl Resolver for SimpleResolver<'_> { + fn resolve(&mut self, idx: u32, _name: &str, _field: &str) -> Option<Export> { + self.imports + .get(idx as usize) + .map(|i| i.get_wasmtime_export()) + } +} + +fn instantiate( + compiled_module: &CompiledModule, + imports: &[Extern], +) -> Result<InstanceHandle, Error> { + let mut resolver = SimpleResolver { imports }; + unsafe { + let instance = compiled_module + .instantiate(&mut resolver) + .map_err(|e| -> Error { + match e { + InstantiationError::StartTrap(trap) => Trap::from_jit(trap).into(), + other => other.into(), + } + })?; + Ok(instance) + } +} + +/// An instantiated WebAssembly module. +/// +/// This type represents the instantiation of a [`Module`]. Once instantiated +/// you can access the [`exports`](Instance::exports) which are of type +/// [`Extern`] and provide the ability to call functions, set globals, read +/// memory, etc. This is where all the fun stuff happens! +/// +/// An [`Instance`] is created from two inputs, a [`Module`] and a list of +/// imports, provided as a list of [`Extern`] values. The [`Module`] is the wasm +/// code that was compiled and we're instantiating, and the [`Extern`] imports +/// are how we're satisfying the imports of the module provided. On successful +/// instantiation an [`Instance`] will automatically invoke the wasm `start` +/// function. +/// +/// When interacting with any wasm code you'll want to make an [`Instance`] to +/// call any code or execute anything! +#[derive(Clone)] +pub struct Instance { + pub(crate) instance_handle: InstanceHandle, + module: Module, + exports: Box<[Extern]>, +} + +impl Instance { + /// Creates a new [`Instance`] from the previously compiled [`Module`] and + /// list of `imports` specified. + /// + /// This method instantiates the `module` provided with the `imports`, + /// following the procedure in the [core specification][inst] to + /// instantiate. Instantiation can fail for a number of reasons (many + /// specified below), but if successful the `start` function will be + /// automatically run (if provided) and then the [`Instance`] will be + /// returned. + /// + /// ## Providing Imports + /// + /// The `imports` array here is a bit tricky. The entries in the list of + /// `imports` are intended to correspond 1:1 with the list of imports + /// returned by [`Module::imports`]. Before calling [`Instance::new`] you'll + /// want to inspect the return value of [`Module::imports`] and, for each + /// import type, create an [`Extern`] which corresponds to that type. + /// These [`Extern`] values are all then collected into a list and passed to + /// this function. + /// + /// Note that this function is intentionally relatively low level. It is the + /// intention that we'll soon provide a [higher level API][issue] which will + /// be much more ergonomic for instantiating modules. If you need the full + /// power of customization of imports, though, this is the method for you! + /// + /// ## Errors + /// + /// This function can fail for a number of reasons, including, but not + /// limited to: + /// + /// * The number of `imports` provided doesn't match the number of imports + /// returned by the `module`'s [`Module::imports`] method. + /// * The type of any [`Extern`] doesn't match the corresponding + /// [`ExternType`] entry that it maps to. + /// * The `start` function in the instance, if present, traps. + /// * Module/instance resource limits are exceeded. + /// + /// When instantiation fails it's recommended to inspect the return value to + /// see why it failed, or bubble it upwards. If you'd like to specifically + /// check for trap errors, you can use `error.downcast::<Trap>()`. + /// + /// [inst]: https://webassembly.github.io/spec/core/exec/modules.html#exec-instantiation + /// [issue]: https://github.com/bytecodealliance/wasmtime/issues/727 + pub fn new(module: &Module, imports: &[Extern]) -> Result<Instance, Error> { + let store = module.store(); + let instance_handle = instantiate(module.compiled_module(), imports)?; + + let exports = { + let mut exports = Vec::with_capacity(module.exports().len()); + for export in module.exports() { + let name = export.name().to_string(); + let export = instance_handle.lookup(&name).expect("export"); + exports.push(Extern::from_wasmtime_export( + store, + instance_handle.clone(), + export, + )); + } + exports.into_boxed_slice() + }; + module.register_frame_info(); + Ok(Instance { + instance_handle, + module: module.clone(), + exports, + }) + } + + /// Returns the associated [`Store`] that this `Instance` is compiled into. + /// + /// This is the [`Store`] that generally serves as a sort of global cache + /// for various instance-related things. + pub fn store(&self) -> &Store { + self.module.store() + } + + /// Returns the associated [`Module`] that this `Instance` instantiated. + /// + /// The corresponding [`Module`] here is a static version of this `Instance` + /// which can be used to learn information such as naming information about + /// various functions. + pub fn module(&self) -> &Module { + &self.module + } + + /// Returns the list of exported items from this [`Instance`]. + /// + /// Note that the exports here do not have names associated with them, + /// they're simply the values that are exported. To learn the value of each + /// export you'll need to consult [`Module::exports`]. The list returned + /// here maps 1:1 with the list that [`Module::exports`] returns, and + /// [`ExportType`] contains the name of each export. + pub fn exports(&self) -> &[Extern] { + &self.exports + } + + /// Looks up an exported [`Extern`] value by name. + /// + /// This method will search the module for an export named `name` and return + /// the value, if found. + /// + /// Returns `None` if there was no export named `name`. + pub fn get_export(&self, name: &str) -> Option<&Extern> { + let (i, _) = self + .module + .exports() + .iter() + .enumerate() + .find(|(_, e)| e.name() == name)?; + Some(&self.exports()[i]) + } + + #[doc(hidden)] + pub fn handle(&self) -> &InstanceHandle { + &self.instance_handle + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +
+//! Wasmtime's embedding API +//! +//! This crate contains a high-level API used to interact with WebAssembly +//! modules. The API here is intended to mirror the proposed [WebAssembly C +//! API](https://github.com/WebAssembly/wasm-c-api), with small extensions here +//! and there to implement Rust idioms. This crate also defines the actual C API +//! itself for consumption from other languages. + +#![deny(missing_docs)] + +mod callable; +mod externals; +mod frame_info; +mod func; +mod instance; +mod module; +mod r#ref; +mod runtime; +mod trampoline; +mod trap; +mod types; +mod values; + +pub use crate::callable::Callable; +pub use crate::externals::*; +pub use crate::frame_info::FrameInfo; +pub use crate::func::{Func, WasmRet, WasmTy}; +pub use crate::instance::Instance; +pub use crate::module::Module; +pub use crate::r#ref::{AnyRef, HostInfo, HostRef}; +pub use crate::runtime::{Config, Engine, OptLevel, Store, Strategy}; +pub use crate::trap::Trap; +pub use crate::types::*; +pub use crate::values::*; + +cfg_if::cfg_if! { + if #[cfg(unix)] { + pub mod unix; + } else if #[cfg(windows)] { + pub mod windows; + } else { + // ... unknown os! + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +
+use crate::frame_info::{GlobalFrameInfoRegistration, FRAME_INFO}; +use crate::runtime::Store; +use crate::types::{ + ExportType, ExternType, FuncType, GlobalType, ImportType, Limits, MemoryType, Mutability, + TableType, ValType, +}; +use anyhow::{bail, Error, Result}; +use std::path::Path; +use std::sync::{Arc, Mutex}; +use wasmparser::{ + validate, CustomSectionKind, ExternalKind, ImportSectionEntryType, ModuleReader, Name, + SectionCode, +}; +use wasmtime_jit::CompiledModule; + +fn into_memory_type(mt: wasmparser::MemoryType) -> Result<MemoryType> { + if mt.shared { + bail!("shared memories are not supported yet"); + } + Ok(MemoryType::new(Limits::new( + mt.limits.initial, + mt.limits.maximum, + ))) +} + +fn into_global_type(gt: wasmparser::GlobalType) -> GlobalType { + let mutability = if gt.mutable { + Mutability::Var + } else { + Mutability::Const + }; + GlobalType::new(into_valtype(>.content_type), mutability) +} + +// `into_valtype` is used for `map` which requires `&T`. +#[allow(clippy::trivially_copy_pass_by_ref)] +fn into_valtype(ty: &wasmparser::Type) -> ValType { + use wasmparser::Type::*; + match ty { + I32 => ValType::I32, + I64 => ValType::I64, + F32 => ValType::F32, + F64 => ValType::F64, + V128 => ValType::V128, + AnyFunc => ValType::FuncRef, + AnyRef => ValType::AnyRef, + _ => unimplemented!("types in into_valtype"), + } +} + +fn into_func_type(mt: wasmparser::FuncType) -> FuncType { + assert_eq!(mt.form, wasmparser::Type::Func); + let params = mt.params.iter().map(into_valtype).collect::<Vec<_>>(); + let returns = mt.returns.iter().map(into_valtype).collect::<Vec<_>>(); + FuncType::new(params.into_boxed_slice(), returns.into_boxed_slice()) +} + +fn into_table_type(tt: wasmparser::TableType) -> TableType { + assert!( + tt.element_type == wasmparser::Type::AnyFunc || tt.element_type == wasmparser::Type::AnyRef + ); + let ty = into_valtype(&tt.element_type); + let limits = Limits::new(tt.limits.initial, tt.limits.maximum); + TableType::new(ty, limits) +} + +/// A compiled WebAssembly module, ready to be instantiated. +/// +/// A `Module` is a compiled in-memory representation of an input WebAssembly +/// binary. A `Module` is then used to create an [`Instance`](crate::Instance) +/// through an instantiation process. You cannot call functions or fetch +/// globals, for example, on a `Module` because it's purely a code +/// representation. Instead you'll need to create an +/// [`Instance`](crate::Instance) to interact with the wasm module. +/// +/// ## Modules and `Clone` +/// +/// Using `clone` on a `Module` is a cheap operation. It will not create an +/// entirely new module, but rather just a new reference to the existing module. +/// In other words it's a shallow copy, not a deep copy. +#[derive(Clone)] +pub struct Module { + inner: Arc<ModuleInner>, +} + +struct ModuleInner { + store: Store, + imports: Box<[ImportType]>, + exports: Box<[ExportType]>, + compiled: CompiledModule, + frame_info_registration: Mutex<Option<Option<GlobalFrameInfoRegistration>>>, + names: Arc<Names>, +} + +pub struct Names { + pub module: Arc<wasmtime_environ::Module>, + pub module_name: Option<String>, +} + +impl Module { + /// Creates a new WebAssembly `Module` from the given in-memory `bytes`. + /// + /// The `bytes` provided must be in one of two formats: + /// + /// * It can be a [binary-encoded][binary] WebAssembly module. This + /// is always supported. + /// * It may also be a [text-encoded][text] instance of the WebAssembly + /// text format. This is only supported when the `wat` feature of this + /// crate is enabled. If this is supplied then the text format will be + /// parsed before validation. Note that the `wat` feature is enabled by + /// default. + /// + /// The data for the wasm module must be loaded in-memory if it's present + /// elsewhere, for example on disk. This requires that the entire binary is + /// loaded into memory all at once, this API does not support streaming + /// compilation of a module. + /// + /// The WebAssembly binary will be decoded and validated. It will also be + /// compiled according to the configuration of the provided `store` and + /// cached in this type. + /// + /// The provided `store` is a global cache for compiled resources as well as + /// configuration for what wasm features are enabled. It's recommended to + /// share a `store` among modules if possible. + /// + /// # Errors + /// + /// This function may fail and return an error. Errors may include + /// situations such as: + /// + /// * The binary provided could not be decoded because it's not a valid + /// WebAssembly binary + /// * The WebAssembly binary may not validate (e.g. contains type errors) + /// * Implementation-specific limits were exceeded with a valid binary (for + /// example too many locals) + /// * The wasm binary may use features that are not enabled in the + /// configuration of `store` + /// * If the `wat` feature is enabled and the input is text, then it may be + /// rejected if it fails to parse. + /// + /// The error returned should contain full information about why module + /// creation failed if one is returned. + /// + /// [binary]: https://webassembly.github.io/spec/core/binary/index.html + /// [text]: https://webassembly.github.io/spec/core/text/index.html + pub fn new(store: &Store, bytes: impl AsRef<[u8]>) -> Result<Module> { + #[cfg(feature = "wat")] + let bytes = wat::parse_bytes(bytes.as_ref())?; + Module::from_binary(store, bytes.as_ref()) + } + + /// Creates a new WebAssembly `Module` from the given in-memory `binary` + /// data. The provided `name` will be used in traps/backtrace details. + /// + /// See [`Module::new`] for other details. + pub fn new_with_name(store: &Store, bytes: impl AsRef<[u8]>, name: &str) -> Result<Module> { + let mut module = Module::new(store, bytes.as_ref())?; + let inner = Arc::get_mut(&mut module.inner).unwrap(); + Arc::get_mut(&mut inner.names).unwrap().module_name = Some(name.to_string()); + Ok(module) + } + + /// Creates a new WebAssembly `Module` from the contents of the given + /// `file` on disk. + /// + /// This is a convenience function that will read the `file` provided and + /// pass the bytes to the [`Module::new`] function. For more information + /// see [`Module::new`] + pub fn from_file(store: &Store, file: impl AsRef<Path>) -> Result<Module> { + #[cfg(feature = "wat")] + let wasm = wat::parse_file(file)?; + #[cfg(not(feature = "wat"))] + let wasm = std::fs::read(file)?; + Module::new(store, &wasm) + } + + /// Creates a new WebAssembly `Module` from the given in-memory `binary` + /// data. + /// + /// This is similar to [`Module::new`] except that it requires that the + /// `binary` input is a WebAssembly binary, the text format is not supported + /// by this function. It's generally recommended to use [`Module::new`], + /// but if it's required to not support the text format this function can be + /// used instead. + pub fn from_binary(store: &Store, binary: &[u8]) -> Result<Module> { + Module::validate(store, binary)?; + // Note that the call to `from_binary_unchecked` here should be ok + // because we previously validated the binary, meaning we're guaranteed + // to pass a valid binary for `store`. + unsafe { Module::from_binary_unchecked(store, binary) } + } + + /// Creates a new WebAssembly `Module` from the given in-memory `binary` + /// data, skipping validation and asserting that `binary` is a valid + /// WebAssembly module. + /// + /// This function is the same as [`Module::new`] except that it skips the + /// call to [`Module::validate`] and it does not support the text format of + /// WebAssembly. The WebAssembly binary is not validated for + /// correctness and it is simply assumed as valid. + /// + /// For more information about creation of a module and the `store` argument + /// see the documentation of [`Module::new`]. + /// + /// # Unsafety + /// + /// This function is `unsafe` due to the unchecked assumption that the input + /// `binary` is valid. If the `binary` is not actually a valid wasm binary it + /// may cause invalid machine code to get generated, cause panics, etc. + /// + /// It is only safe to call this method if [`Module::validate`] succeeds on + /// the same arguments passed to this function. + /// + /// # Errors + /// + /// This function may fail for many of the same reasons as [`Module::new`]. + /// While this assumes that the binary is valid it still needs to actually + /// be somewhat valid for decoding purposes, and the basics of decoding can + /// still fail. + pub unsafe fn from_binary_unchecked(store: &Store, binary: &[u8]) -> Result<Module> { + let mut ret = Module::compile(store, binary)?; + ret.read_imports_and_exports(binary)?; + Ok(ret) + } + + /// Validates `binary` input data as a WebAssembly binary given the + /// configuration in `store`. + /// + /// This function will perform a speedy validation of the `binary` input + /// WebAssembly module (which is in [binary form][binary], the text format + /// is not accepted by this function) and return either `Ok` or `Err` + /// depending on the results of validation. The `store` argument indicates + /// configuration for WebAssembly features, for example, which are used to + /// indicate what should be valid and what shouldn't be. + /// + /// Validation automatically happens as part of [`Module::new`], but is a + /// requirement for [`Module::new_unchecked`] to be safe. + /// + /// # Errors + /// + /// If validation fails for any reason (type check error, usage of a feature + /// that wasn't enabled, etc) then an error with a description of the + /// validation issue will be returned. + /// + /// [binary]: https://webassembly.github.io/spec/core/binary/index.html + pub fn validate(store: &Store, binary: &[u8]) -> Result<()> { + let config = store.engine().config().validating_config.clone(); + validate(binary, Some(config)).map_err(Error::new) + } + + unsafe fn compile(store: &Store, binary: &[u8]) -> Result<Self> { + let compiled = CompiledModule::new( + &mut store.compiler_mut(), + binary, + store.engine().config().debug_info, + )?; + + let names = Arc::new(Names { + module_name: None, + module: compiled.module().clone(), + }); + Ok(Module { + inner: Arc::new(ModuleInner { + store: store.clone(), + imports: Box::new([]), + exports: Box::new([]), + names, + compiled, + frame_info_registration: Mutex::new(None), + }), + }) + } + + pub(crate) fn compiled_module(&self) -> &CompiledModule { + &self.inner.compiled + } + + /// Returns identifier/name that this [`Module`] has. This name + /// is used in traps/backtrace details. + pub fn name(&self) -> Option<&str> { + self.inner.names.module_name.as_deref() + } + + /// Returns the list of imports that this [`Module`] has and must be + /// satisfied. + pub fn imports(&self) -> &[ImportType] { + &self.inner.imports + } + + /// Returns the list of exports that this [`Module`] has and will be + /// available after instantiation. + pub fn exports(&self) -> &[ExportType] { + &self.inner.exports + } + + /// Returns the [`Store`] that this [`Module`] was compiled into. + pub fn store(&self) -> &Store { + &self.inner.store + } + + fn read_imports_and_exports(&mut self, binary: &[u8]) -> Result<()> { + let inner = Arc::get_mut(&mut self.inner).unwrap(); + let mut reader = ModuleReader::new(binary)?; + let mut imports = Vec::new(); + let mut exports = Vec::new(); + let mut memories = Vec::new(); + let mut tables = Vec::new(); + let mut func_sig = Vec::new(); + let mut sigs = Vec::new(); + let mut globals = Vec::new(); + while !reader.eof() { + let section = reader.read()?; + match section.code { + SectionCode::Memory => { + let section = section.get_memory_section_reader()?; + memories.reserve_exact(section.get_count() as usize); + for entry in section { + memories.push(into_memory_type(entry?)?); + } + } + SectionCode::Type => { + let section = section.get_type_section_reader()?; + sigs.reserve_exact(section.get_count() as usize); + for entry in section { + sigs.push(into_func_type(entry?)); + } + } + SectionCode::Function => { + let section = section.get_function_section_reader()?; + func_sig.reserve_exact(section.get_count() as usize); + for entry in section { + func_sig.push(entry?); + } + } + SectionCode::Global => { + let section = section.get_global_section_reader()?; + globals.reserve_exact(section.get_count() as usize); + for entry in section { + globals.push(into_global_type(entry?.ty)); + } + } + SectionCode::Table => { + let section = section.get_table_section_reader()?; + tables.reserve_exact(section.get_count() as usize); + for entry in section { + tables.push(into_table_type(entry?)) + } + } + SectionCode::Import => { + let section = section.get_import_section_reader()?; + imports.reserve_exact(section.get_count() as usize); + for entry in section { + let entry = entry?; + let r#type = match entry.ty { + ImportSectionEntryType::Function(index) => { + func_sig.push(index); + let sig = &sigs[index as usize]; + ExternType::Func(sig.clone()) + } + ImportSectionEntryType::Table(tt) => { + let table = into_table_type(tt); + tables.push(table.clone()); + ExternType::Table(table) + } + ImportSectionEntryType::Memory(mt) => { + let memory = into_memory_type(mt)?; + memories.push(memory.clone()); + ExternType::Memory(memory) + } + ImportSectionEntryType::Global(gt) => { + let global = into_global_type(gt); + globals.push(global.clone()); + ExternType::Global(global) + } + }; + imports.push(ImportType::new(entry.module, entry.field, r#type)); + } + } + SectionCode::Export => { + let section = section.get_export_section_reader()?; + exports.reserve_exact(section.get_count() as usize); + for entry in section { + let entry = entry?; + let r#type = match entry.kind { + ExternalKind::Function => { + let sig_index = func_sig[entry.index as usize] as usize; + let sig = &sigs[sig_index]; + ExternType::Func(sig.clone()) + } + ExternalKind::Table => { + ExternType::Table(tables[entry.index as usize].clone()) + } + ExternalKind::Memory => { + ExternType::Memory(memories[entry.index as usize].clone()) + } + ExternalKind::Global => { + ExternType::Global(globals[entry.index as usize].clone()) + } + }; + exports.push(ExportType::new(entry.field, r#type)); + } + } + SectionCode::Custom { + kind: CustomSectionKind::Name, + .. + } => { + // Read name section. Per spec, ignore invalid custom section. + if let Ok(mut reader) = section.get_name_section_reader() { + while let Ok(entry) = reader.read() { + if let Name::Module(name) = entry { + if let Ok(name) = name.get_name() { + Arc::get_mut(&mut inner.names).unwrap().module_name = + Some(name.to_string()); + } + break; + } + } + } + } + _ => { + // skip other sections + } + } + } + + inner.imports = imports.into(); + inner.exports = exports.into(); + Ok(()) + } + + /// Register this module's stack frame information into the global scope. + /// + /// This is required to ensure that any traps can be properly symbolicated. + pub(crate) fn register_frame_info(&self) { + let mut info = self.inner.frame_info_registration.lock().unwrap(); + if info.is_some() { + return; + } + *info = Some(FRAME_INFO.register(&self.inner.names, &self.inner.compiled)); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +
+#![allow(missing_docs)] + +use std::any::Any; +use std::cell::{self, RefCell}; +use std::fmt; +use std::rc::{Rc, Weak}; + +pub trait HostInfo { + fn finalize(&mut self) {} +} + +trait InternalRefBase: Any { + fn as_any(&self) -> &dyn Any; + fn host_info(&self) -> Option<cell::RefMut<Box<dyn HostInfo>>>; + fn set_host_info(&self, info: Option<Box<dyn HostInfo>>); + fn ptr_eq(&self, other: &dyn InternalRefBase) -> bool; +} + +#[derive(Clone)] +pub struct InternalRef(Rc<dyn InternalRefBase>); + +impl InternalRef { + pub fn is_ref<T: 'static>(&self) -> bool { + let r = self.0.as_any(); + Any::is::<HostRef<T>>(r) + } + pub fn get_ref<T: 'static>(&self) -> HostRef<T> { + let r = self.0.as_any(); + r.downcast_ref::<HostRef<T>>() + .expect("reference is not T type") + .clone() + } +} + +struct AnyAndHostInfo { + any: Box<dyn Any>, + host_info: Option<Box<dyn HostInfo>>, +} + +impl Drop for AnyAndHostInfo { + fn drop(&mut self) { + if let Some(info) = &mut self.host_info { + info.finalize(); + } + } +} + +#[derive(Clone)] +pub struct OtherRef(Rc<RefCell<AnyAndHostInfo>>); + +/// Represents an opaque reference to any data within WebAssembly. +#[derive(Clone)] +pub enum AnyRef { + /// A reference to no data. + Null, + /// A reference to data stored internally in `wasmtime`. + Ref(InternalRef), + /// A reference to data located outside of `wasmtime`. + Other(OtherRef), +} + +impl AnyRef { + /// Creates a new instance of `AnyRef` from `Box<dyn Any>`. + pub fn new(data: Box<dyn Any>) -> Self { + let info = AnyAndHostInfo { + any: data, + host_info: None, + }; + AnyRef::Other(OtherRef(Rc::new(RefCell::new(info)))) + } + + /// Creates a `Null` reference. + pub fn null() -> Self { + AnyRef::Null + } + + /// Returns the data stored in the reference if available. + /// # Panics + /// Panics if the variant isn't `AnyRef::Other`. + pub fn data(&self) -> cell::Ref<Box<dyn Any>> { + match self { + AnyRef::Other(OtherRef(r)) => cell::Ref::map(r.borrow(), |r| &r.any), + _ => panic!("expected AnyRef::Other"), + } + } + + /// Returns true if the two `AnyRef<T>`'s point to the same value (not just + /// values that compare as equal). + pub fn ptr_eq(&self, other: &AnyRef) -> bool { + match (self, other) { + (AnyRef::Null, AnyRef::Null) => true, + (AnyRef::Ref(InternalRef(ref a)), AnyRef::Ref(InternalRef(ref b))) => { + a.ptr_eq(b.as_ref()) + } + (AnyRef::Other(OtherRef(ref a)), AnyRef::Other(OtherRef(ref b))) => Rc::ptr_eq(a, b), + _ => false, + } + } + + /// Returns a mutable reference to the host information if available. + /// # Panics + /// Panics if `AnyRef` is already borrowed or `AnyRef` is `Null`. + pub fn host_info(&self) -> Option<cell::RefMut<Box<dyn HostInfo>>> { + match self { + AnyRef::Null => panic!("null"), + AnyRef::Ref(r) => r.0.host_info(), + AnyRef::Other(r) => { + let info = cell::RefMut::map(r.0.borrow_mut(), |b| &mut b.host_info); + if info.is_none() { + return None; + } + Some(cell::RefMut::map(info, |info| info.as_mut().unwrap())) + } + } + } + + /// Sets the host information for an `AnyRef`. + /// # Panics + /// Panics if `AnyRef` is already borrowed or `AnyRef` is `Null`. + pub fn set_host_info(&self, info: Option<Box<dyn HostInfo>>) { + match self { + AnyRef::Null => panic!("null"), + AnyRef::Ref(r) => r.0.set_host_info(info), + AnyRef::Other(r) => { + r.0.borrow_mut().host_info = info; + } + } + } +} + +impl fmt::Debug for AnyRef { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AnyRef::Null => write!(f, "null"), + AnyRef::Ref(_) => write!(f, "anyref"), + AnyRef::Other(_) => write!(f, "other ref"), + } + } +} + +struct ContentBox<T> { + content: T, + host_info: Option<Box<dyn HostInfo>>, + anyref_data: Weak<dyn InternalRefBase>, +} + +impl<T> Drop for ContentBox<T> { + fn drop(&mut self) { + if let Some(info) = &mut self.host_info { + info.finalize(); + } + } +} + +/// Represents a piece of data located in the host environment. +pub struct HostRef<T>(Rc<RefCell<ContentBox<T>>>); + +impl<T: 'static> HostRef<T> { + /// Creates a new `HostRef<T>` from `T`. + pub fn new(item: T) -> HostRef<T> { + let anyref_data: Weak<HostRef<T>> = Weak::new(); + let content = ContentBox { + content: item, + host_info: None, + anyref_data, + }; + HostRef(Rc::new(RefCell::new(content))) + } + + /// Immutably borrows the wrapped data. + /// # Panics + /// Panics if the value is currently mutably borrowed. + pub fn borrow(&self) -> cell::Ref<T> { + cell::Ref::map(self.0.borrow(), |b| &b.content) + } + + /// Mutably borrows the wrapped data. + /// # Panics + /// Panics if the `HostRef<T>` is already borrowed. + pub fn borrow_mut(&self) -> cell::RefMut<T> { + cell::RefMut::map(self.0.borrow_mut(), |b| &mut b.content) + } + + /// Returns true if the two `HostRef<T>`'s point to the same value (not just + /// values that compare as equal). + pub fn ptr_eq(&self, other: &HostRef<T>) -> bool { + Rc::ptr_eq(&self.0, &other.0) + } + + /// Returns an opaque reference to the wrapped data in the form of + /// an `AnyRef`. + /// # Panics + /// Panics if `HostRef<T>` is already mutably borrowed. + pub fn anyref(&self) -> AnyRef { + let r = self.0.borrow_mut().anyref_data.upgrade(); + if let Some(r) = r { + return AnyRef::Ref(InternalRef(r)); + } + let anyref_data: Rc<dyn InternalRefBase> = Rc::new(self.clone()); + self.0.borrow_mut().anyref_data = Rc::downgrade(&anyref_data); + AnyRef::Ref(InternalRef(anyref_data)) + } +} + +impl<T: 'static> InternalRefBase for HostRef<T> { + fn ptr_eq(&self, other: &dyn InternalRefBase) -> bool { + if let Some(other) = other.as_any().downcast_ref() { + self.ptr_eq(other) + } else { + false + } + } + + fn as_any(&self) -> &dyn Any { + self + } + + fn host_info(&self) -> Option<cell::RefMut<Box<dyn HostInfo>>> { + let info = cell::RefMut::map(self.0.borrow_mut(), |b| &mut b.host_info); + if info.is_none() { + return None; + } + Some(cell::RefMut::map(info, |info| info.as_mut().unwrap())) + } + + fn set_host_info(&self, info: Option<Box<dyn HostInfo>>) { + self.0.borrow_mut().host_info = info; + } +} + +impl<T> Clone for HostRef<T> { + fn clone(&self) -> HostRef<T> { + HostRef(self.0.clone()) + } +} + +impl<T: fmt::Debug> fmt::Debug for HostRef<T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Ref(")?; + self.0.borrow().content.fmt(f)?; + write!(f, ")") + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +
+use anyhow::Result; +use std::cell::RefCell; +use std::fmt; +use std::path::Path; +use std::rc::Rc; +use std::sync::Arc; +use wasmparser::{OperatorValidatorConfig, ValidatingParserConfig}; +use wasmtime_environ::settings::{self, Configurable}; +use wasmtime_environ::CacheConfig; +use wasmtime_jit::{native, CompilationStrategy, Compiler}; + +// Runtime Environment + +// Configuration + +/// Global configuration options used to create an [`Engine`] and customize its +/// behavior. +/// +/// This structure exposed a builder-like interface and is primarily consumed by +/// [`Engine::new()`] +#[derive(Clone)] +pub struct Config { + pub(crate) flags: settings::Builder, + pub(crate) validating_config: ValidatingParserConfig, + pub(crate) debug_info: bool, + pub(crate) strategy: CompilationStrategy, + pub(crate) cache_config: CacheConfig, +} + +impl Config { + /// Creates a new configuration object with the default configuration + /// specified. + pub fn new() -> Config { + let mut flags = settings::builder(); + + // There are two possible traps for division, and this way + // we get the proper one if code traps. + flags + .enable("avoid_div_traps") + .expect("should be valid flag"); + + // Invert cranelift's default-on verification to instead default off. + flags + .set("enable_verifier", "false") + .expect("should be valid flag"); + + Config { + debug_info: false, + validating_config: ValidatingParserConfig { + operator_config: OperatorValidatorConfig { + enable_threads: false, + enable_reference_types: false, + enable_bulk_memory: false, + enable_simd: false, + enable_multi_value: false, + }, + }, + flags, + strategy: CompilationStrategy::Auto, + cache_config: CacheConfig::new_cache_disabled(), + } + } + + /// Configures whether DWARF debug information will be emitted during + /// compilation. + /// + /// By default this option is `false`. + pub fn debug_info(&mut self, enable: bool) -> &mut Self { + self.debug_info = enable; + self + } + + /// Configures whether the WebAssembly threads proposal will be enabled for + /// compilation. + /// + /// The [WebAssembly threads proposal][threads] is not currently fully + /// standardized and is undergoing development. Additionally the support in + /// wasmtime itself is still being worked on. Support for this feature can + /// be enabled through this method for appropriate wasm modules. + /// + /// This feature gates items such as shared memories and atomic + /// instructions. Note that enabling the threads feature will + /// also enable the bulk memory feature. + /// + /// This is `false` by default. + /// + /// [threads]: https://github.com/webassembly/threads + pub fn wasm_threads(&mut self, enable: bool) -> &mut Self { + self.validating_config.operator_config.enable_threads = enable; + // The threads proposal depends on the bulk memory proposal + if enable { + self.wasm_bulk_memory(true); + } + self + } + + /// Configures whether the WebAssembly reference types proposal will be + /// enabled for compilation. + /// + /// The [WebAssembly reference types proposal][proposal] is not currently + /// fully standardized and is undergoing development. Additionally the + /// support in wasmtime itself is still being worked on. Support for this + /// feature can be enabled through this method for appropriate wasm + /// modules. + /// + /// This feature gates items such as the `anyref` type and multiple tables + /// being in a module. Note that enabling the reference types feature will + /// also enable the bulk memory feature. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/reference-types + pub fn wasm_reference_types(&mut self, enable: bool) -> &mut Self { + self.validating_config + .operator_config + .enable_reference_types = enable; + // The reference types proposal depends on the bulk memory proposal + if enable { + self.wasm_bulk_memory(true); + } + self + } + + /// Configures whether the WebAssembly SIMD proposal will be + /// enabled for compilation. + /// + /// The [WebAssembly SIMD proposal][proposal] is not currently + /// fully standardized and is undergoing development. Additionally the + /// support in wasmtime itself is still being worked on. Support for this + /// feature can be enabled through this method for appropriate wasm + /// modules. + /// + /// This feature gates items such as the `v128` type and all of its + /// operators being in a module. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/simd + pub fn wasm_simd(&mut self, enable: bool) -> &mut Self { + self.validating_config.operator_config.enable_simd = enable; + let val = if enable { "true" } else { "false" }; + self.flags + .set("enable_simd", val) + .expect("should be valid flag"); + self + } + + /// Configures whether the WebAssembly bulk memory operations proposal will + /// be enabled for compilation. + /// + /// The [WebAssembly bulk memory operations proposal][proposal] is not + /// currently fully standardized and is undergoing development. + /// Additionally the support in wasmtime itself is still being worked on. + /// Support for this feature can be enabled through this method for + /// appropriate wasm modules. + /// + /// This feature gates items such as the `memory.copy` instruction, passive + /// data/table segments, etc, being in a module. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/bulk-memory-operations + pub fn wasm_bulk_memory(&mut self, enable: bool) -> &mut Self { + self.validating_config.operator_config.enable_bulk_memory = enable; + self + } + + /// Configures whether the WebAssembly multi-value proposal will + /// be enabled for compilation. + /// + /// The [WebAssembly multi-value proposal][proposal] is not + /// currently fully standardized and is undergoing development. + /// Additionally the support in wasmtime itself is still being worked on. + /// Support for this feature can be enabled through this method for + /// appropriate wasm modules. + /// + /// This feature gates functions and blocks returning multiple values in a + /// module, for example. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/multi-value + pub fn wasm_multi_value(&mut self, enable: bool) -> &mut Self { + self.validating_config.operator_config.enable_multi_value = enable; + self + } + + /// Configures which compilation strategy will be used for wasm modules. + /// + /// This method can be used to configure which compiler is used for wasm + /// modules, and for more documentation consult the [`Strategy`] enumeration + /// and its documentation. + /// + /// The default value for this is `Strategy::Auto`. + /// + /// # Errors + /// + /// Some compilation strategies require compile-time options of `wasmtime` + /// itself to be set, but if they're not set and the strategy is specified + /// here then an error will be returned. + pub fn strategy(&mut self, strategy: Strategy) -> Result<&mut Self> { + self.strategy = match strategy { + Strategy::Auto => CompilationStrategy::Auto, + Strategy::Cranelift => CompilationStrategy::Cranelift, + #[cfg(feature = "lightbeam")] + Strategy::Lightbeam => CompilationStrategy::Lightbeam, + #[cfg(not(feature = "lightbeam"))] + Strategy::Lightbeam => { + anyhow::bail!("lightbeam compilation strategy wasn't enabled at compile time"); + } + }; + Ok(self) + } + + /// Configures whether the debug verifier of Cranelift is enabled or not. + /// + /// When Cranelift is used as a code generation backend this will configure + /// it to have the `enable_verifier` flag which will enable a number of debug + /// checks inside of Cranelift. This is largely only useful for the + /// developers of wasmtime itself. + /// + /// The default value for this is `false` + pub fn cranelift_debug_verifier(&mut self, enable: bool) -> &mut Self { + let val = if enable { "true" } else { "false" }; + self.flags + .set("enable_verifier", val) + .expect("should be valid flag"); + self + } + + /// Configures the Cranelift code generator optimization level. + /// + /// When the Cranelift code generator is used you can configure the + /// optimization level used for generated code in a few various ways. For + /// more information see the documentation of [`OptLevel`]. + /// + /// The default value for this is `OptLevel::None`. + pub fn cranelift_opt_level(&mut self, level: OptLevel) -> &mut Self { + let val = match level { + OptLevel::None => "none", + OptLevel::Speed => "speed", + OptLevel::SpeedAndSize => "speed_and_size", + }; + self.flags + .set("opt_level", val) + .expect("should be valid flag"); + self + } + + /// Loads cache configuration specified at `path`. + /// + /// This method will read the file specified by `path` on the filesystem and + /// attempt to load cache configuration from it. This method can also fail + /// due to I/O errors, misconfiguration, syntax errors, etc. For expected + /// syntax in the configuration file see the [documentation online][docs]. + /// + /// By default cache configuration is not enabled or loaded. + /// + /// # Errors + /// + /// This method can fail due to any error that happens when loading the file + /// pointed to by `path` and attempting to load the cache configuration. + /// + /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html + pub fn cache_config_load(&mut self, path: impl AsRef<Path>) -> Result<&mut Self> { + self.cache_config = wasmtime_environ::CacheConfig::from_file(Some(path.as_ref()))?; + Ok(self) + } + + /// Loads cache configuration from the system default path. + /// + /// This commit is the same as [`Config::cache_config_load`] except that it + /// does not take a path argument and instead loads the default + /// configuration present on the system. This is located, for example, on + /// Unix at `$HOME/.config/wasmtime/config.toml` and is typically created + /// with the `wasmtime config new` command. + /// + /// By default cache configuration is not enabled or loaded. + /// + /// # Errors + /// + /// This method can fail due to any error that happens when loading the + /// default system configuration. Note that it is not an error if the + /// default config file does not exist, in which case the default settings + /// for an enabled cache are applied. + /// + /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html + pub fn cache_config_load_default(&mut self) -> Result<&mut Self> { + self.cache_config = wasmtime_environ::CacheConfig::from_file(None)?; + Ok(self) + } +} + +impl Default for Config { + fn default() -> Config { + Config::new() + } +} + +impl fmt::Debug for Config { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let features = &self.validating_config.operator_config; + f.debug_struct("Config") + .field("debug_info", &self.debug_info) + .field("strategy", &self.strategy) + .field("wasm_threads", &features.enable_threads) + .field("wasm_reference_types", &features.enable_reference_types) + .field("wasm_bulk_memory", &features.enable_bulk_memory) + .field("wasm_simd", &features.enable_simd) + .field("wasm_multi_value", &features.enable_multi_value) + .field( + "flags", + &settings::Flags::new(self.flags.clone()).to_string(), + ) + .finish() + } +} + +/// Possible Compilation strategies for a wasm module. +/// +/// This is used as an argument to the [`Config::strategy`] method. +#[non_exhaustive] +#[derive(Clone, Debug)] +pub enum Strategy { + /// An indicator that the compilation strategy should be automatically + /// selected. + /// + /// This is generally what you want for most projects and indicates that the + /// `wasmtime` crate itself should make the decision about what the best + /// code generator for a wasm module is. + /// + /// Currently this always defaults to Cranelift, but the default value will + /// change over time. + Auto, + + /// Currently the default backend, Cranelift aims to be a reasonably fast + /// code generator which generates high quality machine code. + Cranelift, + + /// A single-pass code generator that is faster than Cranelift but doesn't + /// produce as high-quality code. + /// + /// To successfully pass this argument to [`Config::strategy`] the + /// `lightbeam` feature of this crate must be enabled. + Lightbeam, +} + +/// Possible optimization levels for the Cranelift codegen backend. +#[non_exhaustive] +#[derive(Clone, Debug)] +pub enum OptLevel { + /// No optimizations performed, minimizes compilation time by disabling most + /// optimizations. + None, + /// Generates the fastest possible code, but may take longer. + Speed, + /// Similar to `speed`, but also performs transformations aimed at reducing + /// code size. + SpeedAndSize, +} + +// Engine + +/// An `Engine` which is a global context for compilation and management of wasm +/// modules. +/// +/// An engine can be safely shared across threads and is a cheap cloneable +/// handle to the actual engine. The engine itself will be deallocate once all +/// references to it have gone away. +/// +/// Engines store global configuration preferences such as compilation settings, +/// enabled features, etc. You'll likely only need at most one of these for a +/// program. +/// +/// ## Engines and `Clone` +/// +/// Using `clone` on an `Engine` is a cheap operation. It will not create an +/// entirely new engine, but rather just a new reference to the existing engine. +/// In other words it's a shallow copy, not a deep copy. +/// +/// ## Engines and `Default` +/// +/// You can create an engine with default configuration settings using +/// `Engine::default()`. Be sure to consult the documentation of [`Config`] for +/// default settings. +#[derive(Default, Clone)] +pub struct Engine { + config: Arc<Config>, +} + +impl Engine { + /// Creates a new [`Engine`] with the specified compilation and + /// configuration settings. + pub fn new(config: &Config) -> Engine { + Engine { + config: Arc::new(config.clone()), + } + } + + /// Returns the configuration settings that this engine is using. + pub fn config(&self) -> &Config { + &self.config + } +} + +// Store + +/// A `Store` is a shared cache of information between WebAssembly modules. +/// +/// Each `Module` is compiled into a `Store` and a `Store` is associated with an +/// [`Engine`]. You'll use a `Store` to attach to a number of global items in +/// the production of various items for wasm modules. +/// +/// # Stores and `Clone` +/// +/// Using `clone` on a `Store` is a cheap operation. It will not create an +/// entirely new store, but rather just a new reference to the existing object. +/// In other words it's a shallow copy, not a deep copy. +/// +/// ## Stores and `Default` +/// +/// You can create a store with default configuration settings using +/// `Store::default()`. This will create a brand new [`Engine`] with default +/// ocnfiguration (see [`Config`] for more information). +#[derive(Clone)] +pub struct Store { + // FIXME(#777) should be `Arc` and this type should be thread-safe + inner: Rc<StoreInner>, +} + +struct StoreInner { + engine: Engine, + compiler: RefCell<Compiler>, +} + +impl Store { + /// Creates a new store to be associated with the given [`Engine`]. + pub fn new(engine: &Engine) -> Store { + let isa = native::builder().finish(settings::Flags::new(engine.config.flags.clone())); + let compiler = Compiler::new( + isa, + engine.config.strategy, + engine.config.cache_config.clone(), + ); + Store { + inner: Rc::new(StoreInner { + engine: engine.clone(), + compiler: RefCell::new(compiler), + }), + } + } + + /// Returns the [`Engine`] that this store is associated with. + pub fn engine(&self) -> &Engine { + &self.inner.engine + } + + pub(crate) fn compiler(&self) -> std::cell::Ref<'_, Compiler> { + self.inner.compiler.borrow() + } + + pub(crate) fn compiler_mut(&self) -> std::cell::RefMut<'_, Compiler> { + self.inner.compiler.borrow_mut() + } + + /// Returns whether the stores `a` and `b` refer to the same underlying + /// `Store`. + /// + /// Because the `Store` type is reference counted multiple clones may point + /// to the same underlying storage, and this method can be used to determine + /// whether two stores are indeed the same. + pub fn same(a: &Store, b: &Store) -> bool { + Rc::ptr_eq(&a.inner, &b.inner) + } +} + +impl Default for Store { + fn default() -> Store { + Store::new(&Engine::default()) + } +} + +fn _assert_send_sync() { + fn _assert<T: Send + Sync>() {} + _assert::<Engine>(); + _assert::<Config>(); +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +
+//! Support for a calling of an imported function. + +use crate::runtime::Store; +use anyhow::Result; +use std::any::Any; +use std::collections::HashSet; +use std::sync::Arc; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::wasm::DefinedFuncIndex; +use wasmtime_environ::Module; +use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody}; + +pub(crate) fn create_handle( + module: Module, + store: &Store, + finished_functions: PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>, + state: Box<dyn Any>, +) -> Result<InstanceHandle> { + let imports = Imports::new( + HashSet::new(), + PrimaryMap::new(), + PrimaryMap::new(), + PrimaryMap::new(), + PrimaryMap::new(), + ); + let data_initializers = Vec::new(); + + // Compute indices into the shared signature table. + let signatures = module + .signatures + .values() + .map(|sig| store.compiler().signatures().register(sig)) + .collect::<PrimaryMap<_, _>>(); + + unsafe { + Ok(InstanceHandle::new( + Arc::new(module), + store.compiler().trap_registry().register_traps(Vec::new()), + finished_functions.into_boxed_slice(), + imports, + &data_initializers, + signatures.into_boxed_slice(), + None, + state, + )?) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +
+//! Support for a calling of an imported function. + +use super::create_handle::create_handle; +use crate::{Callable, FuncType, Store, Trap, Val}; +use anyhow::{bail, Result}; +use std::any::Any; +use std::cmp; +use std::panic::{self, AssertUnwindSafe}; +use std::rc::Rc; +use wasmtime_environ::entity::{EntityRef, PrimaryMap}; +use wasmtime_environ::ir::types; +use wasmtime_environ::isa::TargetIsa; +use wasmtime_environ::wasm::{DefinedFuncIndex, FuncIndex}; +use wasmtime_environ::{ + ir, settings, CompiledFunction, CompiledFunctionUnwindInfo, Export, Module, +}; +use wasmtime_jit::trampoline::ir::{ + ExternalName, Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, +}; +use wasmtime_jit::trampoline::{ + binemit, pretty_error, Context, FunctionBuilder, FunctionBuilderContext, +}; +use wasmtime_jit::{native, CodeMemory}; +use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody}; + +struct TrampolineState { + func: Rc<dyn Callable + 'static>, + #[allow(dead_code)] + code_memory: CodeMemory, +} + +impl TrampolineState { + fn new(func: Rc<dyn Callable + 'static>, code_memory: CodeMemory) -> Self { + TrampolineState { func, code_memory } + } +} + +unsafe extern "C" fn stub_fn( + vmctx: *mut VMContext, + _caller_vmctx: *mut VMContext, + call_id: u32, + values_vec: *mut i128, +) { + // Here we are careful to use `catch_unwind` to ensure Rust panics don't + // unwind past us. The primary reason for this is that Rust considers it UB + // to unwind past an `extern "C"` function. Here we are in an `extern "C"` + // function and the cross into wasm was through an `extern "C"` function at + // the base of the stack as well. We'll need to wait for assorted RFCs and + // language features to enable this to be done in a sound and stable fashion + // before avoiding catching the panic here. + // + // Also note that there are intentionally no local variables on this stack + // frame. The reason for that is that some of the "raise" functions we have + // below will trigger a longjmp, which won't run local destructors if we + // have any. To prevent leaks we avoid having any local destructors by + // avoiding local variables. + let result = panic::catch_unwind(AssertUnwindSafe(|| call_stub(vmctx, call_id, values_vec))); + + match result { + Ok(Ok(())) => {} + + // If a trap was raised (an error returned from the imported function) + // then we smuggle the trap through `Box<dyn Error>` through to the + // call-site, which gets unwrapped in `Trap::from_jit` later on as we + // convert from the internal `Trap` type to our own `Trap` type in this + // crate. + Ok(Err(trap)) => wasmtime_runtime::raise_user_trap(Box::new(trap)), + + // And finally if the imported function panicked, then we trigger the + // form of unwinding that's safe to jump over wasm code on all + // platforms. + Err(panic) => wasmtime_runtime::resume_panic(panic), + } + + unsafe fn call_stub( + vmctx: *mut VMContext, + call_id: u32, + values_vec: *mut i128, + ) -> Result<(), Trap> { + let instance = InstanceHandle::from_vmctx(vmctx); + + let (args, returns_len) = { + let module = instance.module_ref(); + let signature = &module.signatures[module.functions[FuncIndex::new(call_id as usize)]]; + + let mut args = Vec::new(); + for i in 2..signature.params.len() { + args.push(Val::read_value_from( + values_vec.offset(i as isize - 2), + signature.params[i].value_type, + )) + } + (args, signature.returns.len()) + }; + + let mut returns = vec![Val::null(); returns_len]; + let state = &instance + .host_state() + .downcast_ref::<TrampolineState>() + .expect("state"); + state.func.call(&args, &mut returns)?; + + let module = instance.module_ref(); + let signature = &module.signatures[module.functions[FuncIndex::new(call_id as usize)]]; + for (i, ret) in returns.iter_mut().enumerate() { + if ret.ty().get_wasmtime_type() != Some(signature.returns[i].value_type) { + return Err(Trap::new( + "`Callable` attempted to return an incompatible value", + )); + } + ret.write_value_to(values_vec.add(i)); + } + Ok(()) + } +} + +/// Create a trampoline for invoking a Callable. +fn make_trampoline( + isa: &dyn TargetIsa, + code_memory: &mut CodeMemory, + fn_builder_ctx: &mut FunctionBuilderContext, + call_id: u32, + signature: &ir::Signature, +) -> *mut [VMFunctionBody] { + // Mostly reverse copy of the similar method from wasmtime's + // wasmtime-jit/src/compiler.rs. + let pointer_type = isa.pointer_type(); + let mut stub_sig = ir::Signature::new(isa.frontend_config().default_call_conv); + + // Add the caller/callee `vmctx` parameters. + stub_sig.params.push(ir::AbiParam::special( + pointer_type, + ir::ArgumentPurpose::VMContext, + )); + + // Add the caller `vmctx` parameter. + stub_sig.params.push(ir::AbiParam::new(pointer_type)); + + // Add the `call_id` parameter. + stub_sig.params.push(ir::AbiParam::new(types::I32)); + + // Add the `values_vec` parameter. + stub_sig.params.push(ir::AbiParam::new(pointer_type)); + + // Compute the size of the values vector. The vmctx and caller vmctx are passed separately. + let value_size = 16; + let values_vec_len = ((value_size as usize) + * cmp::max(signature.params.len() - 2, signature.returns.len())) + as u32; + + let mut context = Context::new(); + context.func = Function::with_name_signature(ExternalName::user(0, 0), signature.clone()); + context.func.collect_frame_layout_info(); + + let ss = context.func.create_stack_slot(StackSlotData::new( + StackSlotKind::ExplicitSlot, + values_vec_len, + )); + + { + let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx); + let block0 = builder.create_block(); + + builder.append_block_params_for_function_params(block0); + builder.switch_to_block(block0); + builder.seal_block(block0); + + let values_vec_ptr_val = builder.ins().stack_addr(pointer_type, ss, 0); + let mflags = MemFlags::trusted(); + for i in 2..signature.params.len() { + if i == 0 { + continue; + } + + let val = builder.func.dfg.block_params(block0)[i]; + builder.ins().store( + mflags, + val, + values_vec_ptr_val, + ((i - 2) * value_size) as i32, + ); + } + + let block_params = builder.func.dfg.block_params(block0); + let vmctx_ptr_val = block_params[0]; + let caller_vmctx_ptr_val = block_params[1]; + let call_id_val = builder.ins().iconst(types::I32, call_id as i64); + + let callee_args = vec![ + vmctx_ptr_val, + caller_vmctx_ptr_val, + call_id_val, + values_vec_ptr_val, + ]; + + let new_sig = builder.import_signature(stub_sig); + + let callee_value = builder + .ins() + .iconst(pointer_type, stub_fn as *const VMFunctionBody as i64); + builder + .ins() + .call_indirect(new_sig, callee_value, &callee_args); + + let mflags = MemFlags::trusted(); + let mut results = Vec::new(); + for (i, r) in signature.returns.iter().enumerate() { + let load = builder.ins().load( + r.value_type, + mflags, + values_vec_ptr_val, + (i * value_size) as i32, + ); + results.push(load); + } + builder.ins().return_(&results); + builder.finalize() + } + + let mut code_buf: Vec<u8> = Vec::new(); + let mut reloc_sink = binemit::TrampolineRelocSink {}; + let mut trap_sink = binemit::NullTrapSink {}; + let mut stackmap_sink = binemit::NullStackmapSink {}; + context + .compile_and_emit( + isa, + &mut code_buf, + &mut reloc_sink, + &mut trap_sink, + &mut stackmap_sink, + ) + .map_err(|error| pretty_error(&context.func, Some(isa), error)) + .expect("compile_and_emit"); + + let unwind_info = CompiledFunctionUnwindInfo::new(isa, &context); + + code_memory + .allocate_for_function(&CompiledFunction { + body: code_buf, + jt_offsets: context.func.jt_offsets, + unwind_info, + }) + .expect("allocate_for_function") +} + +pub fn create_handle_with_function( + ft: &FuncType, + func: &Rc<dyn Callable + 'static>, + store: &Store, +) -> Result<InstanceHandle> { + let isa = { + let isa_builder = native::builder(); + let flag_builder = settings::builder(); + isa_builder.finish(settings::Flags::new(flag_builder)) + }; + + let pointer_type = isa.pointer_type(); + let sig = match ft.get_wasmtime_signature(pointer_type) { + Some(sig) => sig.clone(), + None => bail!("not a supported core wasm signature {:?}", ft), + }; + + let mut fn_builder_ctx = FunctionBuilderContext::new(); + let mut module = Module::new(); + let mut finished_functions: PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]> = + PrimaryMap::new(); + let mut code_memory = CodeMemory::new(); + + let sig_id = module.signatures.push(sig.clone()); + let func_id = module.functions.push(sig_id); + module + .exports + .insert("trampoline".to_string(), Export::Function(func_id)); + let trampoline = make_trampoline( + isa.as_ref(), + &mut code_memory, + &mut fn_builder_ctx, + func_id.index() as u32, + &sig, + ); + code_memory.publish(); + + finished_functions.push(trampoline); + + let trampoline_state = TrampolineState::new(func.clone(), code_memory); + + create_handle( + module, + store, + finished_functions, + Box::new(trampoline_state), + ) +} + +pub unsafe fn create_handle_with_raw_function( + ft: &FuncType, + func: *mut [VMFunctionBody], + store: &Store, + state: Box<dyn Any>, +) -> Result<InstanceHandle> { + let isa = { + let isa_builder = native::builder(); + let flag_builder = settings::builder(); + isa_builder.finish(settings::Flags::new(flag_builder)) + }; + + let pointer_type = isa.pointer_type(); + let sig = match ft.get_wasmtime_signature(pointer_type) { + Some(sig) => sig.clone(), + None => bail!("not a supported core wasm signature {:?}", ft), + }; + + let mut module = Module::new(); + let mut finished_functions = PrimaryMap::new(); + + let sig_id = module.signatures.push(sig.clone()); + let func_id = module.functions.push(sig_id); + module + .exports + .insert("trampoline".to_string(), Export::Function(func_id)); + finished_functions.push(func); + + create_handle(module, store, finished_functions, state) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +
+use super::create_handle::create_handle; +use crate::Store; +use crate::{GlobalType, Mutability, Val}; +use anyhow::{bail, Result}; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::{wasm, Module}; +use wasmtime_runtime::InstanceHandle; + +pub fn create_global(store: &Store, gt: &GlobalType, val: Val) -> Result<InstanceHandle> { + let global = wasm::Global { + ty: match gt.content().get_wasmtime_type() { + Some(t) => t, + None => bail!("cannot support {:?} as a wasm global type", gt.content()), + }, + mutability: match gt.mutability() { + Mutability::Const => false, + Mutability::Var => true, + }, + initializer: match val { + Val::I32(i) => wasm::GlobalInit::I32Const(i), + Val::I64(i) => wasm::GlobalInit::I64Const(i), + Val::F32(f) => wasm::GlobalInit::F32Const(f), + Val::F64(f) => wasm::GlobalInit::F64Const(f), + _ => unimplemented!("create_global for {:?}", gt), + }, + }; + let mut module = Module::new(); + let global_id = module.globals.push(global); + module.exports.insert( + "global".to_string(), + wasmtime_environ::Export::Global(global_id), + ); + let handle = create_handle(module, store, PrimaryMap::new(), Box::new(()))?; + Ok(handle) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +
+use super::create_handle::create_handle; +use crate::MemoryType; +use crate::Store; +use anyhow::Result; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::{wasm, Module}; +use wasmtime_runtime::InstanceHandle; + +pub fn create_handle_with_memory(store: &Store, memory: &MemoryType) -> Result<InstanceHandle> { + let mut module = Module::new(); + + let memory = wasm::Memory { + minimum: memory.limits().min(), + maximum: memory.limits().max(), + shared: false, // TODO + }; + let tunable = Default::default(); + + let memory_plan = wasmtime_environ::MemoryPlan::for_memory(memory, &tunable); + let memory_id = module.memory_plans.push(memory_plan); + module.exports.insert( + "memory".to_string(), + wasmtime_environ::Export::Memory(memory_id), + ); + + create_handle(module, store, PrimaryMap::new(), Box::new(())) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +
+//! Utility module to create trampolines in/out WebAssembly module. + +mod create_handle; +mod func; +mod global; +mod memory; +mod table; + +use self::func::create_handle_with_function; +use self::global::create_global; +use self::memory::create_handle_with_memory; +use self::table::create_handle_with_table; +use super::{Callable, FuncType, GlobalType, MemoryType, Store, TableType, Val}; +use anyhow::Result; +use std::any::Any; +use std::rc::Rc; +use wasmtime_runtime::VMFunctionBody; + +pub fn generate_func_export( + ft: &FuncType, + func: &Rc<dyn Callable + 'static>, + store: &Store, +) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> { + let instance = create_handle_with_function(ft, func, store)?; + let export = instance.lookup("trampoline").expect("trampoline export"); + Ok((instance, export)) +} + +/// Note that this is `unsafe` since `func` must be a valid function pointer and +/// have a signature which matches `ft`, otherwise the returned +/// instance/export/etc may exhibit undefined behavior. +pub unsafe fn generate_raw_func_export( + ft: &FuncType, + func: *mut [VMFunctionBody], + store: &Store, + state: Box<dyn Any>, +) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> { + let instance = func::create_handle_with_raw_function(ft, func, store, state)?; + let export = instance.lookup("trampoline").expect("trampoline export"); + Ok((instance, export)) +} + +pub fn generate_global_export( + store: &Store, + gt: &GlobalType, + val: Val, +) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> { + let instance = create_global(store, gt, val)?; + let export = instance.lookup("global").expect("global export"); + Ok((instance, export)) +} + +pub fn generate_memory_export( + store: &Store, + m: &MemoryType, +) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> { + let instance = create_handle_with_memory(store, m)?; + let export = instance.lookup("memory").expect("memory export"); + Ok((instance, export)) +} + +pub fn generate_table_export( + store: &Store, + t: &TableType, +) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> { + let instance = create_handle_with_table(store, t)?; + let export = instance.lookup("table").expect("table export"); + Ok((instance, export)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +
+use super::create_handle::create_handle; +use crate::Store; +use crate::{TableType, ValType}; +use anyhow::{bail, Result}; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::{wasm, Module}; +use wasmtime_runtime::InstanceHandle; + +pub fn create_handle_with_table(store: &Store, table: &TableType) -> Result<InstanceHandle> { + let mut module = Module::new(); + + let table = wasm::Table { + minimum: table.limits().min(), + maximum: table.limits().max(), + ty: match table.element() { + ValType::FuncRef => wasm::TableElementType::Func, + _ => bail!("cannot support {:?} as a table element", table.element()), + }, + }; + let tunable = Default::default(); + + let table_plan = wasmtime_environ::TablePlan::for_table(table, &tunable); + let table_id = module.table_plans.push(table_plan); + module.exports.insert( + "table".to_string(), + wasmtime_environ::Export::Table(table_id), + ); + + create_handle(module, store, PrimaryMap::new(), Box::new(())) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +
+use crate::frame_info::FRAME_INFO; +use crate::FrameInfo; +use backtrace::Backtrace; +use std::fmt; +use std::sync::Arc; + +/// A struct representing an aborted instruction execution, with a message +/// indicating the cause. +#[derive(Clone)] +pub struct Trap { + inner: Arc<TrapInner>, +} + +struct TrapInner { + message: String, + wasm_trace: Vec<FrameInfo>, + native_trace: Backtrace, +} + +fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) { + (t, t) +} + +impl Trap { + /// Creates a new `Trap` with `message`. + /// # Example + /// ``` + /// let trap = wasmtime::Trap::new("unexpected error"); + /// assert_eq!("unexpected error", trap.message()); + /// ``` + pub fn new<I: Into<String>>(message: I) -> Self { + Trap::new_with_trace(message.into(), Backtrace::new_unresolved()) + } + + pub(crate) fn from_jit(jit: wasmtime_runtime::Trap) -> Self { + match jit { + wasmtime_runtime::Trap::User(error) => { + // Since we're the only one using the wasmtime internals (in + // theory) we should only see user errors which were originally + // created from our own `Trap` type (see the trampoline module + // with functions). + // + // If this unwrap trips for someone we'll need to tweak the + // return type of this function to probably be `anyhow::Error` + // or something like that. + *error + .downcast() + .expect("only `Trap` user errors are supported") + } + wasmtime_runtime::Trap::Wasm { desc, backtrace } => { + Trap::new_with_trace(desc.to_string(), backtrace) + } + } + } + + fn new_with_trace(message: String, native_trace: Backtrace) -> Self { + let mut wasm_trace = Vec::new(); + for frame in native_trace.frames() { + let pc = frame.ip() as usize; + if let Some(info) = FRAME_INFO.lookup(pc) { + wasm_trace.push(info); + } + } + Trap { + inner: Arc::new(TrapInner { + message, + wasm_trace, + native_trace, + }), + } + } + + /// Returns a reference the `message` stored in `Trap`. + pub fn message(&self) -> &str { + &self.inner.message + } + + /// Returns a list of function frames in WebAssembly code that led to this + /// trap happening. + pub fn trace(&self) -> &[FrameInfo] { + &self.inner.wasm_trace + } +} + +impl fmt::Debug for Trap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Trap") + .field("message", &self.inner.message) + .field("wasm_trace", &self.inner.wasm_trace) + .field("native_trace", &self.inner.native_trace) + .finish() + } +} + +impl fmt::Display for Trap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.inner.message)?; + let trace = self.trace(); + if trace.is_empty() { + return Ok(()); + } + writeln!(f, "\nwasm backtrace:")?; + for (i, frame) in self.trace().iter().enumerate() { + let name = frame.module_name().unwrap_or("<unknown>"); + write!(f, " {}: {}!", i, name)?; + match frame.func_name() { + Some(name) => match rustc_demangle::try_demangle(name) { + Ok(name) => write!(f, "{}", name)?, + Err(_) => write!(f, "{}", name)?, + }, + None => write!(f, "<wasm function {}>", frame.func_index())?, + } + writeln!(f, "")?; + } + Ok(()) + } +} + +impl std::error::Error for Trap {} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +
+use wasmtime_environ::{ir, wasm}; + +// Type Representations + +// Type attributes + +/// Indicator of whether a global is mutable or not +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Mutability { + /// The global is constant and its value does not change + Const, + /// The value of the global can change over time + Var, +} + +/// Limits of tables/memories where the units of the limits are defined by the +/// table/memory types. +/// +/// A minimum is always available but the maximum may not be present. +#[derive(Debug, Clone)] +pub struct Limits { + min: u32, + max: Option<u32>, +} + +impl Limits { + /// Creates a new set of limits with the minimum and maximum both specified. + pub fn new(min: u32, max: Option<u32>) -> Limits { + Limits { min, max } + } + + /// Creates a new `Limits` with the `min` specified and no maximum specified. + pub fn at_least(min: u32) -> Limits { + Limits::new(min, None) + } + + /// Returns the minimum amount for these limits. + pub fn min(&self) -> u32 { + self.min + } + + /// Returns the maximum amount for these limits, if specified. + pub fn max(&self) -> Option<u32> { + self.max + } +} + +// Value Types + +/// A list of all possible value types in WebAssembly. +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum ValType { + /// Signed 32 bit integer. + I32, + /// Signed 64 bit integer. + I64, + /// Floating point 32 bit integer. + F32, + /// Floating point 64 bit integer. + F64, + /// A 128 bit number. + V128, + /// A reference to opaque data in the Wasm instance. + AnyRef, /* = 128 */ + /// A reference to a Wasm function. + FuncRef, +} + +impl ValType { + /// Returns true if `ValType` matches any of the numeric types. (e.g. `I32`, + /// `I64`, `F32`, `F64`). + pub fn is_num(&self) -> bool { + match self { + ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 => true, + _ => false, + } + } + + /// Returns true if `ValType` matches either of the reference types. + pub fn is_ref(&self) -> bool { + match self { + ValType::AnyRef | ValType::FuncRef => true, + _ => false, + } + } + + pub(crate) fn get_wasmtime_type(&self) -> Option<ir::Type> { + match self { + ValType::I32 => Some(ir::types::I32), + ValType::I64 => Some(ir::types::I64), + ValType::F32 => Some(ir::types::F32), + ValType::F64 => Some(ir::types::F64), + ValType::V128 => Some(ir::types::I8X16), + _ => None, + } + } + + pub(crate) fn from_wasmtime_type(ty: ir::Type) -> Option<ValType> { + match ty { + ir::types::I32 => Some(ValType::I32), + ir::types::I64 => Some(ValType::I64), + ir::types::F32 => Some(ValType::F32), + ir::types::F64 => Some(ValType::F64), + ir::types::I8X16 => Some(ValType::V128), + _ => None, + } + } +} + +// External Types + +/// A list of all possible types which can be externally referenced from a +/// WebAssembly module. +/// +/// This list can be found in [`ImportType`] or [`ExportType`], so these types +/// can either be imported or exported. +#[derive(Debug, Clone)] +pub enum ExternType { + /// This external type is the type of a WebAssembly function. + Func(FuncType), + /// This external type is the type of a WebAssembly global. + Global(GlobalType), + /// This external type is the type of a WebAssembly table. + Table(TableType), + /// This external type is the type of a WebAssembly memory. + Memory(MemoryType), +} + +macro_rules! accessors { + ($(($variant:ident($ty:ty) $get:ident $unwrap:ident))*) => ($( + /// Attempt to return the underlying type of this external type, + /// returning `None` if it is a different type. + pub fn $get(&self) -> Option<&$ty> { + if let ExternType::$variant(e) = self { + Some(e) + } else { + None + } + } + + /// Returns the underlying descriptor of this [`ExternType`], panicking + /// if it is a different type. + /// + /// # Panics + /// + /// Panics if `self` is not of the right type. + pub fn $unwrap(&self) -> &$ty { + self.$get().expect(concat!("expected ", stringify!($ty))) + } + )*) +} + +impl ExternType { + accessors! { + (Func(FuncType) func unwrap_func) + (Global(GlobalType) global unwrap_global) + (Table(TableType) table unwrap_table) + (Memory(MemoryType) memory unwrap_memory) + } +} + +// Function Types +fn from_wasmtime_abiparam(param: &ir::AbiParam) -> Option<ValType> { + assert_eq!(param.purpose, ir::ArgumentPurpose::Normal); + ValType::from_wasmtime_type(param.value_type) +} + +/// A descriptor for a function in a WebAssembly module. +/// +/// WebAssembly functions can have 0 or more parameters and results. +#[derive(Debug, Clone)] +pub struct FuncType { + params: Box<[ValType]>, + results: Box<[ValType]>, +} + +impl FuncType { + /// Creates a new function descriptor from the given parameters and results. + /// + /// The function descriptor returned will represent a function which takes + /// `params` as arguments and returns `results` when it is finished. + pub fn new(params: Box<[ValType]>, results: Box<[ValType]>) -> FuncType { + FuncType { params, results } + } + + /// Returns the list of parameter types for this function. + pub fn params(&self) -> &[ValType] { + &self.params + } + + /// Returns the list of result types for this function. + pub fn results(&self) -> &[ValType] { + &self.results + } + + /// Returns `Some` if this function signature was compatible with cranelift, + /// or `None` if one of the types/results wasn't supported or compatible + /// with cranelift. + pub(crate) fn get_wasmtime_signature(&self, pointer_type: ir::Type) -> Option<ir::Signature> { + use wasmtime_environ::ir::{types, AbiParam, ArgumentPurpose, Signature}; + use wasmtime_jit::native; + let call_conv = native::call_conv(); + let mut params = self + .params + .iter() + .map(|p| p.get_wasmtime_type().map(AbiParam::new)) + .collect::<Option<Vec<_>>>()?; + let returns = self + .results + .iter() + .map(|p| p.get_wasmtime_type().map(AbiParam::new)) + .collect::<Option<Vec<_>>>()?; + params.insert(0, AbiParam::special(types::I64, ArgumentPurpose::VMContext)); + params.insert(1, AbiParam::new(pointer_type)); + + Some(Signature { + params, + returns, + call_conv, + }) + } + + /// Returns `None` if any types in the signature can't be converted to the + /// types in this crate, but that should very rarely happen and largely only + /// indicate a bug in our cranelift integration. + pub(crate) fn from_wasmtime_signature(signature: ir::Signature) -> Option<FuncType> { + let params = signature + .params + .iter() + .skip(2) // skip the caller/callee vmctx + .map(|p| from_wasmtime_abiparam(p)) + .collect::<Option<Vec<_>>>()?; + let results = signature + .returns + .iter() + .map(|p| from_wasmtime_abiparam(p)) + .collect::<Option<Vec<_>>>()?; + Some(FuncType { + params: params.into_boxed_slice(), + results: results.into_boxed_slice(), + }) + } +} + +// Global Types + +/// A WebAssembly global descriptor. +/// +/// This type describes an instance of a global in a WebAssembly module. Globals +/// are local to an [`Instance`](crate::Instance) and are either immutable or +/// mutable. +#[derive(Debug, Clone)] +pub struct GlobalType { + content: ValType, + mutability: Mutability, +} + +impl GlobalType { + /// Creates a new global descriptor of the specified `content` type and + /// whether or not it's mutable. + pub fn new(content: ValType, mutability: Mutability) -> GlobalType { + GlobalType { + content, + mutability, + } + } + + /// Returns the value type of this global descriptor. + pub fn content(&self) -> &ValType { + &self.content + } + + /// Returns whether or not this global is mutable. + pub fn mutability(&self) -> Mutability { + self.mutability + } + + /// Returns `None` if the wasmtime global has a type that we can't + /// represent, but that should only very rarely happen and indicate a bug. + pub(crate) fn from_wasmtime_global(global: &wasm::Global) -> Option<GlobalType> { + let ty = ValType::from_wasmtime_type(global.ty)?; + let mutability = if global.mutability { + Mutability::Var + } else { + Mutability::Const + }; + Some(GlobalType::new(ty, mutability)) + } +} + +// Table Types + +/// A descriptor for a table in a WebAssembly module. +/// +/// Tables are contiguous chunks of a specific element, typically a `funcref` or +/// an `anyref`. The most common use for tables is a function table through +/// which `call_indirect` can invoke other functions. +#[derive(Debug, Clone)] +pub struct TableType { + element: ValType, + limits: Limits, +} + +impl TableType { + /// Creates a new table descriptor which will contain the specified + /// `element` and have the `limits` applied to its length. + pub fn new(element: ValType, limits: Limits) -> TableType { + TableType { element, limits } + } + + /// Returns the element value type of this table. + pub fn element(&self) -> &ValType { + &self.element + } + + /// Returns the limits, in units of elements, of this table. + pub fn limits(&self) -> &Limits { + &self.limits + } + + pub(crate) fn from_wasmtime_table(table: &wasm::Table) -> TableType { + assert!(if let wasm::TableElementType::Func = table.ty { + true + } else { + false + }); + let ty = ValType::FuncRef; + let limits = Limits::new(table.minimum, table.maximum); + TableType::new(ty, limits) + } +} + +// Memory Types + +/// A descriptor for a WebAssembly memory type. +/// +/// Memories are described in units of pages (64KB) and represent contiguous +/// chunks of addressable memory. +#[derive(Debug, Clone)] +pub struct MemoryType { + limits: Limits, +} + +impl MemoryType { + /// Creates a new descriptor for a WebAssembly memory given the specified + /// limits of the memory. + pub fn new(limits: Limits) -> MemoryType { + MemoryType { limits } + } + + /// Returns the limits (in pages) that are configured for this memory. + pub fn limits(&self) -> &Limits { + &self.limits + } + + pub(crate) fn from_wasmtime_memory(memory: &wasm::Memory) -> MemoryType { + MemoryType::new(Limits::new(memory.minimum, memory.maximum)) + } +} + +// Import Types + +/// A descriptor for an imported value into a wasm module. +/// +/// This type is primarily accessed from the +/// [`Module::imports`](crate::Module::imports) API. Each [`ImportType`] +/// describes an import into the wasm module with the module/name that it's +/// imported from as well as the type of item that's being imported. +#[derive(Debug, Clone)] +pub struct ImportType { + module: String, + name: String, + ty: ExternType, +} + +impl ImportType { + /// Creates a new import descriptor which comes from `module` and `name` and + /// is of type `ty`. + pub fn new(module: &str, name: &str, ty: ExternType) -> ImportType { + ImportType { + module: module.to_string(), + name: name.to_string(), + ty, + } + } + + /// Returns the module name that this import is expected to come from. + pub fn module(&self) -> &str { + &self.module + } + + /// Returns the field name of the module that this import is expected to + /// come from. + pub fn name(&self) -> &str { + &self.name + } + + /// Returns the expected type of this import. + pub fn ty(&self) -> &ExternType { + &self.ty + } +} + +// Export Types + +/// A descriptor for an exported WebAssembly value. +/// +/// This type is primarily accessed from the +/// [`Module::exports`](crate::Module::exports) accessor and describes what +/// names are exported from a wasm module and the type of the item that is +/// exported. +#[derive(Debug, Clone)] +pub struct ExportType { + name: String, + ty: ExternType, +} + +impl ExportType { + /// Creates a new export which is exported with the given `name` and has the + /// given `ty`. + pub fn new(name: &str, ty: ExternType) -> ExportType { + ExportType { + name: name.to_string(), + ty, + } + } + + /// Returns the name by which this export is known by. + pub fn name(&self) -> &str { + &self.name + } + + /// Returns the type of this export. + pub fn ty(&self) -> &ExternType { + &self.ty + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +
+//! Unix-specific extension for the `wasmtime` crate. +//! +//! This module is only available on Unix targets, for example Linux and macOS. +//! It is not available on Windows, for example. Note that the import path for +//! this module is `wasmtime::unix::...`, which is intended to emphasize that it +//! is platform-specific. +//! +//! The traits contained in this module are intended to extend various types +//! throughout the `wasmtime` crate with extra functionality that's only +//! available on Unix. + +use crate::Instance; + +/// Extensions for the [`Instance`] type only available on Unix. +pub trait InstanceExt { + // TODO: needs more docs? + /// The signal handler must be + /// [async-signal-safe](http://man7.org/linux/man-pages/man7/signal-safety.7.html). + unsafe fn set_signal_handler<H>(&self, handler: H) + where + H: 'static + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool; +} + +impl InstanceExt for Instance { + unsafe fn set_signal_handler<H>(&self, handler: H) + where + H: 'static + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool, + { + self.instance_handle.clone().set_signal_handler(handler); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +
+use crate::r#ref::AnyRef; +use crate::{Func, Store, ValType}; +use anyhow::{bail, Result}; +use std::ptr; +use wasmtime_environ::ir; + +/// Possible runtime values that a WebAssembly module can either consume or +/// produce. +#[derive(Debug, Clone)] +pub enum Val { + /// A 32-bit integer + I32(i32), + + /// A 64-bit integer + I64(i64), + + /// A 32-bit float. + /// + /// Note that the raw bits of the float are stored here, and you can use + /// `f32::from_bits` to create an `f32` value. + F32(u32), + + /// A 64-bit float. + /// + /// Note that the raw bits of the float are stored here, and you can use + /// `f64::from_bits` to create an `f64` value. + F64(u64), + + /// An `anyref` value which can hold opaque data to the wasm instance itself. + /// + /// Note that this is a nullable value as well. + AnyRef(AnyRef), + + /// A first-class reference to a WebAssembly function. + FuncRef(Func), + + /// A 128-bit number + V128(u128), +} + +macro_rules! accessors { + ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($( + /// Attempt to access the underlying value of this `Val`, returning + /// `None` if it is not the correct type. + pub fn $get(&self) -> Option<$ty> { + if let Val::$variant($bind) = self { + Some($cvt) + } else { + None + } + } + + /// Returns the underlying value of this `Val`, panicking if it's the + /// wrong type. + /// + /// # Panics + /// + /// Panics if `self` is not of the right type. + pub fn $unwrap(&self) -> $ty { + self.$get().expect(concat!("expected ", stringify!($ty))) + } + )*) +} + +impl Val { + /// Returns a null `anyref` value. + pub fn null() -> Val { + Val::AnyRef(AnyRef::null()) + } + + /// Returns the corresponding [`ValType`] for this `Val`. + pub fn ty(&self) -> ValType { + match self { + Val::I32(_) => ValType::I32, + Val::I64(_) => ValType::I64, + Val::F32(_) => ValType::F32, + Val::F64(_) => ValType::F64, + Val::AnyRef(_) => ValType::AnyRef, + Val::FuncRef(_) => ValType::FuncRef, + Val::V128(_) => ValType::V128, + } + } + + pub(crate) unsafe fn write_value_to(&self, p: *mut i128) { + match self { + Val::I32(i) => ptr::write(p as *mut i32, *i), + Val::I64(i) => ptr::write(p as *mut i64, *i), + Val::F32(u) => ptr::write(p as *mut u32, *u), + Val::F64(u) => ptr::write(p as *mut u64, *u), + Val::V128(b) => ptr::write(p as *mut u128, *b), + _ => unimplemented!("Val::write_value_to"), + } + } + + pub(crate) unsafe fn read_value_from(p: *const i128, ty: ir::Type) -> Val { + match ty { + ir::types::I32 => Val::I32(ptr::read(p as *const i32)), + ir::types::I64 => Val::I64(ptr::read(p as *const i64)), + ir::types::F32 => Val::F32(ptr::read(p as *const u32)), + ir::types::F64 => Val::F64(ptr::read(p as *const u64)), + ir::types::I8X16 => Val::V128(ptr::read(p as *const u128)), + _ => unimplemented!("Val::read_value_from"), + } + } + + accessors! { + e + (I32(i32) i32 unwrap_i32 *e) + (I64(i64) i64 unwrap_i64 *e) + (F32(f32) f32 unwrap_f32 f32::from_bits(*e)) + (F64(f64) f64 unwrap_f64 f64::from_bits(*e)) + (FuncRef(&Func) funcref unwrap_funcref e) + (V128(u128) v128 unwrap_v128 *e) + } + + /// Attempt to access the underlying value of this `Val`, returning + /// `None` if it is not the correct type. + /// + /// This will return `Some` for both the `AnyRef` and `FuncRef` types. + pub fn anyref(&self) -> Option<AnyRef> { + match self { + Val::AnyRef(e) => Some(e.clone()), + _ => None, + } + } + + /// Returns the underlying value of this `Val`, panicking if it's the + /// wrong type. + /// + /// # Panics + /// + /// Panics if `self` is not of the right type. + pub fn unwrap_anyref(&self) -> AnyRef { + self.anyref().expect("expected anyref") + } +} + +impl From<i32> for Val { + fn from(val: i32) -> Val { + Val::I32(val) + } +} + +impl From<i64> for Val { + fn from(val: i64) -> Val { + Val::I64(val) + } +} + +impl From<f32> for Val { + fn from(val: f32) -> Val { + Val::F32(val.to_bits()) + } +} + +impl From<f64> for Val { + fn from(val: f64) -> Val { + Val::F64(val.to_bits()) + } +} + +impl From<AnyRef> for Val { + fn from(val: AnyRef) -> Val { + Val::AnyRef(val) + } +} + +impl From<Func> for Val { + fn from(val: Func) -> Val { + Val::FuncRef(val) + } +} + +pub(crate) fn into_checked_anyfunc( + val: Val, + store: &Store, +) -> Result<wasmtime_runtime::VMCallerCheckedAnyfunc> { + Ok(match val { + Val::AnyRef(AnyRef::Null) => wasmtime_runtime::VMCallerCheckedAnyfunc { + func_ptr: ptr::null(), + type_index: wasmtime_runtime::VMSharedSignatureIndex::default(), + vmctx: ptr::null_mut(), + }, + Val::FuncRef(f) => { + let (vmctx, func_ptr, signature) = match f.wasmtime_export() { + wasmtime_runtime::Export::Function { + vmctx, + address, + signature, + } => (*vmctx, *address, signature), + _ => panic!("expected function export"), + }; + let type_index = store.compiler().signatures().register(signature); + wasmtime_runtime::VMCallerCheckedAnyfunc { + func_ptr, + type_index, + vmctx, + } + } + _ => bail!("val is not funcref"), + }) +} + +pub(crate) fn from_checked_anyfunc( + item: wasmtime_runtime::VMCallerCheckedAnyfunc, + store: &Store, +) -> Val { + if item.type_index == wasmtime_runtime::VMSharedSignatureIndex::default() { + return Val::AnyRef(AnyRef::Null); + } + let signature = store + .compiler() + .signatures() + .lookup(item.type_index) + .expect("signature"); + let instance_handle = unsafe { wasmtime_runtime::InstanceHandle::from_vmctx(item.vmctx) }; + let export = wasmtime_runtime::Export::Function { + address: item.func_ptr, + signature, + vmctx: item.vmctx, + }; + let f = Func::from_wasmtime_function(export, store, instance_handle); + Val::FuncRef(f) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +
+use crate::transform::AddressTransform; +use gimli::constants; +use gimli::read; +use gimli::{Reader, UnitSectionOffset}; +use std::collections::{HashMap, HashSet}; + +#[derive(Debug)] +pub struct Dependencies { + edges: HashMap<UnitSectionOffset, HashSet<UnitSectionOffset>>, + roots: HashSet<UnitSectionOffset>, +} + +impl Dependencies { + fn new() -> Dependencies { + Dependencies { + edges: HashMap::new(), + roots: HashSet::new(), + } + } + + fn add_edge(&mut self, a: UnitSectionOffset, b: UnitSectionOffset) { + use std::collections::hash_map::Entry; + match self.edges.entry(a) { + Entry::Occupied(mut o) => { + o.get_mut().insert(b); + } + Entry::Vacant(v) => { + let mut set = HashSet::new(); + set.insert(b); + v.insert(set); + } + } + } + + fn add_root(&mut self, root: UnitSectionOffset) { + self.roots.insert(root); + } + + pub fn get_reachable(&self) -> HashSet<UnitSectionOffset> { + let mut reachable = self.roots.clone(); + let mut queue = Vec::new(); + for i in self.roots.iter() { + if let Some(deps) = self.edges.get(i) { + for j in deps { + if reachable.contains(j) { + continue; + } + reachable.insert(*j); + queue.push(*j); + } + } + } + while let Some(i) = queue.pop() { + if let Some(deps) = self.edges.get(&i) { + for j in deps { + if reachable.contains(j) { + continue; + } + reachable.insert(*j); + queue.push(*j); + } + } + } + reachable + } +} + +pub fn build_dependencies<R: Reader<Offset = usize>>( + dwarf: &read::Dwarf<R>, + at: &AddressTransform, +) -> read::Result<Dependencies> { + let mut deps = Dependencies::new(); + let mut units = dwarf.units(); + while let Some(unit) = units.next()? { + build_unit_dependencies(unit, dwarf, at, &mut deps)?; + } + Ok(deps) +} + +fn build_unit_dependencies<R: Reader<Offset = usize>>( + header: read::CompilationUnitHeader<R>, + dwarf: &read::Dwarf<R>, + at: &AddressTransform, + deps: &mut Dependencies, +) -> read::Result<()> { + let unit = dwarf.unit(header)?; + let mut tree = unit.entries_tree(None)?; + let root = tree.root()?; + build_die_dependencies(root, dwarf, &unit, at, deps)?; + Ok(()) +} + +fn has_die_back_edge<R: Reader<Offset = usize>>(die: &read::DebuggingInformationEntry<R>) -> bool { + match die.tag() { + constants::DW_TAG_variable + | constants::DW_TAG_constant + | constants::DW_TAG_inlined_subroutine + | constants::DW_TAG_lexical_block + | constants::DW_TAG_label + | constants::DW_TAG_with_stmt + | constants::DW_TAG_try_block + | constants::DW_TAG_catch_block + | constants::DW_TAG_template_type_parameter + | constants::DW_TAG_member + | constants::DW_TAG_formal_parameter => true, + _ => false, + } +} + +fn has_valid_code_range<R: Reader<Offset = usize>>( + die: &read::DebuggingInformationEntry<R>, + dwarf: &read::Dwarf<R>, + unit: &read::Unit<R>, + at: &AddressTransform, +) -> read::Result<bool> { + match die.tag() { + constants::DW_TAG_subprogram => { + if let Some(ranges_attr) = die.attr_value(constants::DW_AT_ranges)? { + let offset = match ranges_attr { + read::AttributeValue::RangeListsRef(val) => val, + read::AttributeValue::DebugRngListsIndex(index) => { + dwarf.ranges_offset(unit, index)? + } + _ => return Ok(false), + }; + let mut has_valid_base = if let Some(read::AttributeValue::Addr(low_pc)) = + die.attr_value(constants::DW_AT_low_pc)? + { + Some(at.can_translate_address(low_pc)) + } else { + None + }; + let mut it = dwarf.ranges.raw_ranges(offset, unit.encoding())?; + while let Some(range) = it.next()? { + // If at least one of the range addresses can be converted, + // declaring code range as valid. + match range { + read::RawRngListEntry::AddressOrOffsetPair { .. } + if has_valid_base.is_some() => + { + if has_valid_base.unwrap() { + return Ok(true); + } + } + read::RawRngListEntry::StartEnd { begin, .. } + | read::RawRngListEntry::StartLength { begin, .. } + | read::RawRngListEntry::AddressOrOffsetPair { begin, .. } => { + if at.can_translate_address(begin) { + return Ok(true); + } + } + read::RawRngListEntry::StartxEndx { begin, .. } + | read::RawRngListEntry::StartxLength { begin, .. } => { + let addr = dwarf.address(unit, begin)?; + if at.can_translate_address(addr) { + return Ok(true); + } + } + read::RawRngListEntry::BaseAddress { addr } => { + has_valid_base = Some(at.can_translate_address(addr)); + } + read::RawRngListEntry::BaseAddressx { addr } => { + let addr = dwarf.address(unit, addr)?; + has_valid_base = Some(at.can_translate_address(addr)); + } + read::RawRngListEntry::OffsetPair { .. } => (), + } + } + return Ok(false); + } else if let Some(low_pc) = die.attr_value(constants::DW_AT_low_pc)? { + if let read::AttributeValue::Addr(a) = low_pc { + return Ok(at.can_translate_address(a)); + } + } + } + _ => (), + } + Ok(false) +} + +fn build_die_dependencies<R: Reader<Offset = usize>>( + die: read::EntriesTreeNode<R>, + dwarf: &read::Dwarf<R>, + unit: &read::Unit<R>, + at: &AddressTransform, + deps: &mut Dependencies, +) -> read::Result<()> { + let entry = die.entry(); + let offset = entry.offset().to_unit_section_offset(unit); + let mut attrs = entry.attrs(); + while let Some(attr) = attrs.next()? { + build_attr_dependencies(&attr, offset, dwarf, unit, at, deps)?; + } + + let mut children = die.children(); + while let Some(child) = children.next()? { + let child_entry = child.entry(); + let child_offset = child_entry.offset().to_unit_section_offset(unit); + deps.add_edge(child_offset, offset); + if has_die_back_edge(child_entry) { + deps.add_edge(offset, child_offset); + } + if has_valid_code_range(child_entry, dwarf, unit, at)? { + deps.add_root(child_offset); + } + build_die_dependencies(child, dwarf, unit, at, deps)?; + } + Ok(()) +} + +fn build_attr_dependencies<R: Reader<Offset = usize>>( + attr: &read::Attribute<R>, + offset: UnitSectionOffset, + _dwarf: &read::Dwarf<R>, + unit: &read::Unit<R>, + _at: &AddressTransform, + deps: &mut Dependencies, +) -> read::Result<()> { + match attr.value() { + read::AttributeValue::UnitRef(val) => { + let ref_offset = val.to_unit_section_offset(unit); + deps.add_edge(offset, ref_offset); + } + read::AttributeValue::DebugInfoRef(val) => { + let ref_offset = UnitSectionOffset::DebugInfoOffset(val); + deps.add_edge(offset, ref_offset); + } + _ => (), + } + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +
+//! Debug utils for WebAssembly using Cranelift. + +#![allow(clippy::cast_ptr_alignment)] + +use anyhow::Error; +use faerie::{Artifact, Decl}; +use more_asserts::assert_gt; +use target_lexicon::{BinaryFormat, Triple}; +use wasmtime_environ::isa::TargetFrontendConfig; +use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges}; + +pub use crate::read_debuginfo::{read_debuginfo, DebugInfoData, WasmFileInfo}; +pub use crate::transform::transform_dwarf; +pub use crate::write_debuginfo::{emit_dwarf, ResolvedSymbol, SymbolResolver}; + +mod gc; +mod read_debuginfo; +mod transform; +mod write_debuginfo; + +struct FunctionRelocResolver {} +impl SymbolResolver for FunctionRelocResolver { + fn resolve_symbol(&self, symbol: usize, addend: i64) -> ResolvedSymbol { + let name = format!("_wasm_function_{}", symbol); + ResolvedSymbol::Reloc { name, addend } + } +} + +pub fn emit_debugsections( + obj: &mut Artifact, + vmctx_info: &ModuleVmctxInfo, + target_config: TargetFrontendConfig, + debuginfo_data: &DebugInfoData, + at: &ModuleAddressMap, + ranges: &ValueLabelsRanges, +) -> Result<(), Error> { + let resolver = FunctionRelocResolver {}; + let dwarf = transform_dwarf(target_config, debuginfo_data, at, vmctx_info, ranges)?; + emit_dwarf(obj, dwarf, &resolver)?; + Ok(()) +} + +struct ImageRelocResolver<'a> { + func_offsets: &'a Vec<u64>, +} + +impl<'a> SymbolResolver for ImageRelocResolver<'a> { + fn resolve_symbol(&self, symbol: usize, addend: i64) -> ResolvedSymbol { + let func_start = self.func_offsets[symbol]; + ResolvedSymbol::PhysicalAddress(func_start + addend as u64) + } +} + +pub fn emit_debugsections_image( + triple: Triple, + target_config: TargetFrontendConfig, + debuginfo_data: &DebugInfoData, + vmctx_info: &ModuleVmctxInfo, + at: &ModuleAddressMap, + ranges: &ValueLabelsRanges, + funcs: &[(*const u8, usize)], +) -> Result<Vec<u8>, Error> { + let func_offsets = &funcs + .iter() + .map(|(ptr, _)| *ptr as u64) + .collect::<Vec<u64>>(); + let mut obj = Artifact::new(triple, String::from("module")); + let resolver = ImageRelocResolver { func_offsets }; + let dwarf = transform_dwarf(target_config, debuginfo_data, at, vmctx_info, ranges)?; + + // Assuming all functions in the same code block, looking min/max of its range. + assert_gt!(funcs.len(), 0); + let mut segment_body: (usize, usize) = (!0, 0); + for (body_ptr, body_len) in funcs { + segment_body.0 = std::cmp::min(segment_body.0, *body_ptr as usize); + segment_body.1 = std::cmp::max(segment_body.1, *body_ptr as usize + body_len); + } + let segment_body = (segment_body.0 as *const u8, segment_body.1 - segment_body.0); + + let body = unsafe { std::slice::from_raw_parts(segment_body.0, segment_body.1) }; + obj.declare_with("all", Decl::function(), body.to_vec())?; + + emit_dwarf(&mut obj, dwarf, &resolver)?; + + // LLDB is too "magical" about mach-o, generating elf + let mut bytes = obj.emit_as(BinaryFormat::Elf)?; + // elf is still missing details... + convert_faerie_elf_to_loadable_file(&mut bytes, segment_body.0); + + // let mut file = ::std::fs::File::create(::std::path::Path::new("test.o")).expect("file"); + // ::std::io::Write::write(&mut file, &bytes).expect("write"); + + Ok(bytes) +} + +fn convert_faerie_elf_to_loadable_file(bytes: &mut Vec<u8>, code_ptr: *const u8) { + use std::ffi::CStr; + use std::os::raw::c_char; + + assert!( + bytes[0x4] == 2 && bytes[0x5] == 1, + "bits and endianess in .ELF" + ); + let e_phoff = unsafe { *(bytes.as_ptr().offset(0x20) as *const u64) }; + let e_phnum = unsafe { *(bytes.as_ptr().offset(0x38) as *const u16) }; + assert!( + e_phoff == 0 && e_phnum == 0, + "program header table is empty" + ); + let e_phentsize = unsafe { *(bytes.as_ptr().offset(0x36) as *const u16) }; + assert_eq!(e_phentsize, 0x38, "size of ph"); + let e_shentsize = unsafe { *(bytes.as_ptr().offset(0x3A) as *const u16) }; + assert_eq!(e_shentsize, 0x40, "size of sh"); + + let e_shoff = unsafe { *(bytes.as_ptr().offset(0x28) as *const u64) }; + let e_shnum = unsafe { *(bytes.as_ptr().offset(0x3C) as *const u16) }; + let mut shstrtab_off = 0; + let mut segment = None; + for i in 0..e_shnum { + let off = e_shoff as isize + i as isize * e_shentsize as isize; + let sh_type = unsafe { *(bytes.as_ptr().offset(off + 0x4) as *const u32) }; + if sh_type == /* SHT_SYMTAB */ 3 { + shstrtab_off = unsafe { *(bytes.as_ptr().offset(off + 0x18) as *const u64) }; + } + if sh_type != /* SHT_PROGBITS */ 1 { + continue; + } + // It is a SHT_PROGBITS, but we need to check sh_name to ensure it is our function + let sh_name = unsafe { + let sh_name_off = *(bytes.as_ptr().offset(off) as *const u32); + CStr::from_ptr( + bytes + .as_ptr() + .offset((shstrtab_off + sh_name_off as u64) as isize) + as *const c_char, + ) + .to_str() + .expect("name") + }; + if sh_name != ".text.all" { + continue; + } + + assert!(segment.is_none()); + // Functions was added at emit_debugsections_image as .text.all. + // Patch vaddr, and save file location and its size. + unsafe { + *(bytes.as_ptr().offset(off + 0x10) as *mut u64) = code_ptr as u64; + }; + let sh_offset = unsafe { *(bytes.as_ptr().offset(off + 0x18) as *const u64) }; + let sh_size = unsafe { *(bytes.as_ptr().offset(off + 0x20) as *const u64) }; + segment = Some((sh_offset, code_ptr, sh_size)); + // Fix name too: cut it to just ".text" + unsafe { + let sh_name_off = *(bytes.as_ptr().offset(off) as *const u32); + bytes[(shstrtab_off + sh_name_off as u64) as usize + ".text".len()] = 0; + } + } + + // LLDB wants segment with virtual address set, placing them at the end of ELF. + let ph_off = bytes.len(); + if let Some((sh_offset, v_offset, sh_size)) = segment { + let segment = vec![0; 0x38]; + unsafe { + *(segment.as_ptr() as *mut u32) = /* PT_LOAD */ 0x1; + *(segment.as_ptr().offset(0x8) as *mut u64) = sh_offset; + *(segment.as_ptr().offset(0x10) as *mut u64) = v_offset as u64; + *(segment.as_ptr().offset(0x18) as *mut u64) = v_offset as u64; + *(segment.as_ptr().offset(0x20) as *mut u64) = sh_size; + *(segment.as_ptr().offset(0x28) as *mut u64) = sh_size; + } + bytes.extend_from_slice(&segment); + } else { + unreachable!(); + } + + // It is somewhat loadable ELF file at this moment. + // Update e_flags, e_phoff and e_phnum. + unsafe { + *(bytes.as_ptr().offset(0x10) as *mut u16) = /* ET_DYN */ 3; + *(bytes.as_ptr().offset(0x20) as *mut u64) = ph_off as u64; + *(bytes.as_ptr().offset(0x38) as *mut u16) = 1 as u16; + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +
+use gimli::{ + DebugAbbrev, DebugAddr, DebugInfo, DebugLine, DebugLineStr, DebugLoc, DebugLocLists, + DebugRanges, DebugRngLists, DebugStr, DebugStrOffsets, DebugTypes, EndianSlice, LittleEndian, + LocationLists, RangeLists, +}; +use std::collections::HashMap; +use std::path::PathBuf; +use wasmparser::{self, ModuleReader, SectionCode}; + +trait Reader: gimli::Reader<Offset = usize, Endian = LittleEndian> {} + +impl<'input> Reader for gimli::EndianSlice<'input, LittleEndian> {} + +pub use wasmparser::Type as WasmType; + +pub type Dwarf<'input> = gimli::Dwarf<gimli::EndianSlice<'input, LittleEndian>>; + +#[derive(Debug)] +pub struct FunctionMetadata { + pub params: Box<[WasmType]>, + pub locals: Box<[(u32, WasmType)]>, +} + +#[derive(Debug)] +pub struct WasmFileInfo { + pub path: Option<PathBuf>, + pub code_section_offset: u64, + pub funcs: Box<[FunctionMetadata]>, +} + +#[derive(Debug)] +pub struct NameSection { + pub module_name: Option<String>, + pub func_names: HashMap<u32, String>, + pub locals_names: HashMap<u32, HashMap<u32, String>>, +} + +#[derive(Debug)] +pub struct DebugInfoData<'a> { + pub dwarf: Dwarf<'a>, + pub name_section: Option<NameSection>, + pub wasm_file: WasmFileInfo, +} + +fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> { + const EMPTY_SECTION: &[u8] = &[]; + + let endian = LittleEndian; + let debug_str = DebugStr::new(sections.get(".debug_str").unwrap_or(&EMPTY_SECTION), endian); + let debug_abbrev = DebugAbbrev::new( + sections.get(".debug_abbrev").unwrap_or(&EMPTY_SECTION), + endian, + ); + let debug_info = DebugInfo::new( + sections.get(".debug_info").unwrap_or(&EMPTY_SECTION), + endian, + ); + let debug_line = DebugLine::new( + sections.get(".debug_line").unwrap_or(&EMPTY_SECTION), + endian, + ); + + if sections.contains_key(".debug_addr") { + panic!("Unexpected .debug_addr"); + } + + let debug_addr = DebugAddr::from(EndianSlice::new(EMPTY_SECTION, endian)); + + if sections.contains_key(".debug_line_str") { + panic!("Unexpected .debug_line_str"); + } + + let debug_line_str = DebugLineStr::from(EndianSlice::new(EMPTY_SECTION, endian)); + let debug_str_sup = DebugStr::from(EndianSlice::new(EMPTY_SECTION, endian)); + + if sections.contains_key(".debug_rnglists") { + panic!("Unexpected .debug_rnglists"); + } + + let debug_ranges = match sections.get(".debug_ranges") { + Some(section) => DebugRanges::new(section, endian), + None => DebugRanges::new(EMPTY_SECTION, endian), + }; + let debug_rnglists = DebugRngLists::new(EMPTY_SECTION, endian); + let ranges = RangeLists::new(debug_ranges, debug_rnglists); + + if sections.contains_key(".debug_loclists") { + panic!("Unexpected .debug_loclists"); + } + + let debug_loc = match sections.get(".debug_loc") { + Some(section) => DebugLoc::new(section, endian), + None => DebugLoc::new(EMPTY_SECTION, endian), + }; + let debug_loclists = DebugLocLists::new(EMPTY_SECTION, endian); + let locations = LocationLists::new(debug_loc, debug_loclists); + + if sections.contains_key(".debug_str_offsets") { + panic!("Unexpected .debug_str_offsets"); + } + + let debug_str_offsets = DebugStrOffsets::from(EndianSlice::new(EMPTY_SECTION, endian)); + + if sections.contains_key(".debug_types") { + panic!("Unexpected .debug_types"); + } + + let debug_types = DebugTypes::from(EndianSlice::new(EMPTY_SECTION, endian)); + + Dwarf { + debug_abbrev, + debug_addr, + debug_info, + debug_line, + debug_line_str, + debug_str, + debug_str_offsets, + debug_str_sup, + debug_types, + locations, + ranges, + } +} + +fn read_name_section(reader: wasmparser::NameSectionReader) -> wasmparser::Result<NameSection> { + let mut module_name = None; + let mut func_names = HashMap::new(); + let mut locals_names = HashMap::new(); + for i in reader.into_iter() { + match i? { + wasmparser::Name::Module(m) => { + module_name = Some(String::from(m.get_name()?)); + } + wasmparser::Name::Function(f) => { + let mut reader = f.get_map()?; + while let Ok(naming) = reader.read() { + func_names.insert(naming.index, String::from(naming.name)); + } + } + wasmparser::Name::Local(l) => { + let mut reader = l.get_function_local_reader()?; + while let Ok(f) = reader.read() { + let mut names = HashMap::new(); + let mut reader = f.get_map()?; + while let Ok(naming) = reader.read() { + names.insert(naming.index, String::from(naming.name)); + } + locals_names.insert(f.func_index, names); + } + } + } + } + let result = NameSection { + module_name, + func_names, + locals_names, + }; + Ok(result) +} + +pub fn read_debuginfo(data: &[u8]) -> DebugInfoData { + let mut reader = ModuleReader::new(data).expect("reader"); + let mut sections = HashMap::new(); + let mut name_section = None; + let mut code_section_offset = 0; + + let mut signatures_params: Vec<Box<[WasmType]>> = Vec::new(); + let mut func_params_refs: Vec<usize> = Vec::new(); + let mut func_locals: Vec<Box<[(u32, WasmType)]>> = Vec::new(); + + while !reader.eof() { + let section = reader.read().expect("section"); + match section.code { + SectionCode::Custom { name, .. } => { + if name.starts_with(".debug_") { + let mut reader = section.get_binary_reader(); + let len = reader.bytes_remaining(); + sections.insert(name, reader.read_bytes(len).expect("bytes")); + } + if name == "name" { + if let Ok(reader) = section.get_name_section_reader() { + if let Ok(section) = read_name_section(reader) { + name_section = Some(section); + } + } + } + } + SectionCode::Type => { + signatures_params = section + .get_type_section_reader() + .expect("type section") + .into_iter() + .map(|ft| ft.expect("type").params) + .collect::<Vec<_>>(); + } + SectionCode::Function => { + func_params_refs = section + .get_function_section_reader() + .expect("function section") + .into_iter() + .map(|index| index.expect("func index") as usize) + .collect::<Vec<_>>(); + } + SectionCode::Code => { + code_section_offset = section.range().start as u64; + func_locals = section + .get_code_section_reader() + .expect("code section") + .into_iter() + .map(|body| { + let locals = body + .expect("body") + .get_locals_reader() + .expect("locals reader"); + locals + .into_iter() + .collect::<Result<Vec<_>, _>>() + .expect("locals data") + .into_boxed_slice() + }) + .collect::<Vec<_>>(); + } + _ => (), + } + } + + let func_meta = func_params_refs + .into_iter() + .zip(func_locals.into_iter()) + .map(|(params_index, locals)| FunctionMetadata { + params: signatures_params[params_index].clone(), + locals, + }) + .collect::<Vec<_>>(); + + DebugInfoData { + dwarf: convert_sections(sections), + name_section, + wasm_file: WasmFileInfo { + path: None, + code_section_offset, + funcs: func_meta.into_boxed_slice(), + }, + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +
+use crate::WasmFileInfo; +use gimli::write; +use more_asserts::assert_le; +use std::collections::BTreeMap; +use std::collections::HashMap; +use std::iter::FromIterator; +use wasmtime_environ::entity::{EntityRef, PrimaryMap}; +use wasmtime_environ::ir::SourceLoc; +use wasmtime_environ::wasm::DefinedFuncIndex; +use wasmtime_environ::{FunctionAddressMap, ModuleAddressMap}; + +pub type GeneratedAddress = usize; +pub type WasmAddress = u64; + +/// Contains mapping of the generated address to its original +/// source location. +#[derive(Debug)] +pub struct AddressMap { + pub generated: GeneratedAddress, + pub wasm: WasmAddress, +} + +/// Information about generated function code: its body start, +/// length, and instructions addresses. +#[derive(Debug)] +pub struct FunctionMap { + pub offset: GeneratedAddress, + pub len: GeneratedAddress, + pub wasm_start: WasmAddress, + pub wasm_end: WasmAddress, + pub addresses: Box<[AddressMap]>, +} + +/// Mapping of the source location to its generated code range. +#[derive(Debug)] +struct Position { + wasm_pos: WasmAddress, + gen_start: GeneratedAddress, + gen_end: GeneratedAddress, +} + +/// Mapping of continuous range of source location to its generated +/// code. The positions are always in accending order for search. +#[derive(Debug)] +struct Range { + wasm_start: WasmAddress, + wasm_end: WasmAddress, + gen_start: GeneratedAddress, + gen_end: GeneratedAddress, + positions: Box<[Position]>, +} + +/// Helper function address lookup data. Contains ranges start positions +/// index and ranges data. The multiple ranges can include the same +/// original source position. The index (B-Tree) uses range start +/// position as a key. +#[derive(Debug)] +struct FuncLookup { + index: Vec<(WasmAddress, Box<[usize]>)>, + ranges: Box<[Range]>, +} + +/// Mapping of original functions to generated code locations/ranges. +#[derive(Debug)] +struct FuncTransform { + start: WasmAddress, + end: WasmAddress, + index: DefinedFuncIndex, + lookup: FuncLookup, +} + +/// Module functions mapping to generated code. +#[derive(Debug)] +pub struct AddressTransform { + map: PrimaryMap<DefinedFuncIndex, FunctionMap>, + func: Vec<(WasmAddress, FuncTransform)>, +} + +/// Returns a wasm bytecode offset in the code section from SourceLoc. +pub fn get_wasm_code_offset(loc: SourceLoc, code_section_offset: u64) -> WasmAddress { + // Code section size <= 4GB, allow wrapped SourceLoc to recover the overflow. + loc.bits().wrapping_sub(code_section_offset as u32) as WasmAddress +} + +fn build_function_lookup( + ft: &FunctionAddressMap, + code_section_offset: u64, +) -> (WasmAddress, WasmAddress, FuncLookup) { + assert_le!(code_section_offset, ft.start_srcloc.bits() as u64); + let fn_start = get_wasm_code_offset(ft.start_srcloc, code_section_offset); + let fn_end = get_wasm_code_offset(ft.end_srcloc, code_section_offset); + assert_le!(fn_start, fn_end); + + // Build ranges of continuous source locations. The new ranges starts when + // non-descending order is interrupted. Assuming the same origin location can + // be present in multiple ranges. + let mut range_wasm_start = fn_start; + let mut range_gen_start = ft.body_offset; + let mut last_wasm_pos = range_wasm_start; + let mut ranges = Vec::new(); + let mut ranges_index = BTreeMap::new(); + let mut current_range = Vec::new(); + for t in &ft.instructions { + if t.srcloc.is_default() { + continue; + } + + let offset = get_wasm_code_offset(t.srcloc, code_section_offset); + assert_le!(fn_start, offset); + assert_le!(offset, fn_end); + + let inst_gen_start = t.code_offset; + let inst_gen_end = t.code_offset + t.code_len; + + if last_wasm_pos > offset { + // Start new range. + ranges_index.insert(range_wasm_start, ranges.len()); + ranges.push(Range { + wasm_start: range_wasm_start, + wasm_end: last_wasm_pos, + gen_start: range_gen_start, + gen_end: inst_gen_start, + positions: current_range.into_boxed_slice(), + }); + range_wasm_start = offset; + range_gen_start = inst_gen_start; + current_range = Vec::new(); + } + // Continue existing range: add new wasm->generated code position. + current_range.push(Position { + wasm_pos: offset, + gen_start: inst_gen_start, + gen_end: inst_gen_end, + }); + last_wasm_pos = offset; + } + let last_gen_addr = ft.body_offset + ft.body_len; + ranges_index.insert(range_wasm_start, ranges.len()); + ranges.push(Range { + wasm_start: range_wasm_start, + wasm_end: fn_end, + gen_start: range_gen_start, + gen_end: last_gen_addr, + positions: current_range.into_boxed_slice(), + }); + + // Making ranges lookup faster by building index: B-tree with every range + // start position that maps into list of active ranges at this position. + let ranges = ranges.into_boxed_slice(); + let mut active_ranges = Vec::new(); + let mut index = BTreeMap::new(); + let mut last_wasm_pos = None; + for (wasm_start, range_index) in ranges_index { + if Some(wasm_start) == last_wasm_pos { + active_ranges.push(range_index); + continue; + } + if let Some(position) = last_wasm_pos { + index.insert(position, active_ranges.clone().into_boxed_slice()); + } + active_ranges.retain(|r| ranges[*r].wasm_end.cmp(&wasm_start) != std::cmp::Ordering::Less); + active_ranges.push(range_index); + last_wasm_pos = Some(wasm_start); + } + index.insert(last_wasm_pos.unwrap(), active_ranges.into_boxed_slice()); + let index = Vec::from_iter(index.into_iter()); + (fn_start, fn_end, FuncLookup { index, ranges }) +} + +fn build_function_addr_map( + at: &ModuleAddressMap, + code_section_offset: u64, +) -> PrimaryMap<DefinedFuncIndex, FunctionMap> { + let mut map = PrimaryMap::new(); + for (_, ft) in at { + let mut fn_map = Vec::new(); + for t in &ft.instructions { + if t.srcloc.is_default() { + continue; + } + let offset = get_wasm_code_offset(t.srcloc, code_section_offset); + fn_map.push(AddressMap { + generated: t.code_offset, + wasm: offset, + }); + } + + if cfg!(debug) { + // fn_map is sorted by the generated field -- see FunctionAddressMap::instructions. + for i in 1..fn_map.len() { + assert_le!(fn_map[i - 1].generated, fn_map[i].generated); + } + } + + map.push(FunctionMap { + offset: ft.body_offset, + len: ft.body_len, + wasm_start: get_wasm_code_offset(ft.start_srcloc, code_section_offset), + wasm_end: get_wasm_code_offset(ft.end_srcloc, code_section_offset), + addresses: fn_map.into_boxed_slice(), + }); + } + map +} + +struct TransformRangeIter<'a> { + addr: u64, + indicies: &'a [usize], + ranges: &'a [Range], +} + +impl<'a> TransformRangeIter<'a> { + fn new(func: &'a FuncTransform, addr: u64) -> Self { + let found = match func + .lookup + .index + .binary_search_by(|entry| entry.0.cmp(&addr)) + { + Ok(i) => Some(&func.lookup.index[i].1), + Err(i) => { + if i > 0 { + Some(&func.lookup.index[i - 1].1) + } else { + None + } + } + }; + if let Some(range_indices) = found { + TransformRangeIter { + addr, + indicies: range_indices, + ranges: &func.lookup.ranges, + } + } else { + unreachable!(); + } + } +} +impl<'a> Iterator for TransformRangeIter<'a> { + type Item = (usize, usize); + fn next(&mut self) -> Option<Self::Item> { + if let Some((first, tail)) = self.indicies.split_first() { + let range_index = *first; + let range = &self.ranges[range_index]; + self.indicies = tail; + let address = match range + .positions + .binary_search_by(|a| a.wasm_pos.cmp(&self.addr)) + { + Ok(i) => range.positions[i].gen_start, + Err(i) => { + if i == 0 { + range.gen_start + } else { + range.positions[i - 1].gen_end + } + } + }; + Some((address, range_index)) + } else { + None + } + } +} + +struct TransformRangeEndIter<'a> { + addr: u64, + indicies: &'a [usize], + ranges: &'a [Range], +} + +impl<'a> TransformRangeEndIter<'a> { + fn new(func: &'a FuncTransform, addr: u64) -> Self { + let found = match func + .lookup + .index + .binary_search_by(|entry| entry.0.cmp(&addr)) + { + Ok(i) => Some(&func.lookup.index[i].1), + Err(i) => { + if i > 0 { + Some(&func.lookup.index[i - 1].1) + } else { + None + } + } + }; + if let Some(range_indices) = found { + TransformRangeEndIter { + addr, + indicies: range_indices, + ranges: &func.lookup.ranges, + } + } else { + unreachable!(); + } + } +} + +impl<'a> Iterator for TransformRangeEndIter<'a> { + type Item = (usize, usize); + fn next(&mut self) -> Option<Self::Item> { + while let Some((first, tail)) = self.indicies.split_first() { + let range_index = *first; + let range = &self.ranges[range_index]; + if range.wasm_start >= self.addr { + continue; + } + self.indicies = tail; + let address = match range + .positions + .binary_search_by(|a| a.wasm_pos.cmp(&self.addr)) + { + Ok(i) => range.positions[i].gen_end, + Err(i) => { + if i == range.positions.len() { + range.gen_end + } else { + range.positions[i].gen_start + } + } + }; + return Some((address, range_index)); + } + None + } +} + +impl AddressTransform { + pub fn new(at: &ModuleAddressMap, wasm_file: &WasmFileInfo) -> Self { + let code_section_offset = wasm_file.code_section_offset; + + let mut func = BTreeMap::new(); + for (i, ft) in at { + let (fn_start, fn_end, lookup) = build_function_lookup(ft, code_section_offset); + + func.insert( + fn_start, + FuncTransform { + start: fn_start, + end: fn_end, + index: i, + lookup, + }, + ); + } + + let map = build_function_addr_map(at, code_section_offset); + let func = Vec::from_iter(func.into_iter()); + AddressTransform { map, func } + } + + fn find_func(&self, addr: u64) -> Option<&FuncTransform> { + // TODO check if we need to include end address + let func = match self.func.binary_search_by(|entry| entry.0.cmp(&addr)) { + Ok(i) => &self.func[i].1, + Err(i) => { + if i > 0 { + &self.func[i - 1].1 + } else { + return None; + } + } + }; + if addr >= func.start { + return Some(func); + } + None + } + + pub fn find_func_index(&self, addr: u64) -> Option<DefinedFuncIndex> { + self.find_func(addr).map(|f| f.index) + } + + pub fn translate_raw(&self, addr: u64) -> Option<(DefinedFuncIndex, GeneratedAddress)> { + if addr == 0 { + // It's normally 0 for debug info without the linked code. + return None; + } + if let Some(func) = self.find_func(addr) { + if addr == func.end { + // Clamp last address to the end to extend translation to the end + // of the function. + let map = &self.map[func.index]; + return Some((func.index, map.len)); + } + let first_result = TransformRangeIter::new(func, addr).next(); + first_result.map(|(address, _)| (func.index, address)) + } else { + // Address was not found: function was not compiled? + None + } + } + + pub fn can_translate_address(&self, addr: u64) -> bool { + self.translate(addr).is_some() + } + + pub fn translate(&self, addr: u64) -> Option<write::Address> { + self.translate_raw(addr) + .map(|(func_index, address)| write::Address::Symbol { + symbol: func_index.index(), + addend: address as i64, + }) + } + + pub fn translate_ranges_raw( + &self, + start: u64, + end: u64, + ) -> Option<(DefinedFuncIndex, Vec<(GeneratedAddress, GeneratedAddress)>)> { + if start == 0 { + // It's normally 0 for debug info without the linked code. + return None; + } + if let Some(func) = self.find_func(start) { + let mut starts: HashMap<usize, usize> = + HashMap::from_iter(TransformRangeIter::new(func, start).map(|(a, r)| (r, a))); + let mut result = Vec::new(); + TransformRangeEndIter::new(func, end).for_each(|(a, r)| { + let range_start = if let Some(range_start) = starts.get(&r) { + let range_start = *range_start; + starts.remove(&r); + range_start + } else { + let range = &func.lookup.ranges[r]; + range.gen_start + }; + result.push((range_start, a)); + }); + for (r, range_start) in starts { + let range = &func.lookup.ranges[r]; + result.push((range_start, range.gen_end)); + } + return Some((func.index, result)); + } + // Address was not found: function was not compiled? + None + } + + pub fn translate_ranges(&self, start: u64, end: u64) -> Vec<(write::Address, u64)> { + self.translate_ranges_raw(start, end) + .map_or(vec![], |(func_index, ranges)| { + ranges + .iter() + .map(|(start, end)| { + ( + write::Address::Symbol { + symbol: func_index.index(), + addend: *start as i64, + }, + (*end - *start) as u64, + ) + }) + .collect::<Vec<_>>() + }) + } + + pub fn map(&self) -> &PrimaryMap<DefinedFuncIndex, FunctionMap> { + &self.map + } + + pub fn func_range(&self, index: DefinedFuncIndex) -> (GeneratedAddress, GeneratedAddress) { + let map = &self.map[index]; + (map.offset, map.offset + map.len) + } + + pub fn func_source_range(&self, index: DefinedFuncIndex) -> (WasmAddress, WasmAddress) { + let map = &self.map[index]; + (map.wasm_start, map.wasm_end) + } + + pub fn convert_to_code_range( + &self, + addr: write::Address, + len: u64, + ) -> (GeneratedAddress, GeneratedAddress) { + let start = if let write::Address::Symbol { addend, .. } = addr { + // TODO subtract self.map[symbol].offset ? + addend as GeneratedAddress + } else { + unreachable!(); + }; + (start, start + len as GeneratedAddress) + } +} + +#[cfg(test)] +mod tests { + use super::{build_function_lookup, get_wasm_code_offset, AddressTransform}; + use crate::read_debuginfo::WasmFileInfo; + use gimli::write::Address; + use std::iter::FromIterator; + use wasmtime_environ::entity::PrimaryMap; + use wasmtime_environ::ir::SourceLoc; + use wasmtime_environ::{FunctionAddressMap, InstructionAddressMap, ModuleAddressMap}; + + #[test] + fn test_get_wasm_code_offset() { + let offset = get_wasm_code_offset(SourceLoc::new(3), 1); + assert_eq!(2, offset); + let offset = get_wasm_code_offset(SourceLoc::new(16), 0xF000_0000); + assert_eq!(0x1000_0010, offset); + let offset = get_wasm_code_offset(SourceLoc::new(1), 0x20_8000_0000); + assert_eq!(0x8000_0001, offset); + } + + fn create_simple_func(wasm_offset: u32) -> FunctionAddressMap { + FunctionAddressMap { + instructions: vec![ + InstructionAddressMap { + srcloc: SourceLoc::new(wasm_offset + 2), + code_offset: 5, + code_len: 3, + }, + InstructionAddressMap { + srcloc: SourceLoc::new(wasm_offset + 7), + code_offset: 15, + code_len: 8, + }, + ], + start_srcloc: SourceLoc::new(wasm_offset), + end_srcloc: SourceLoc::new(wasm_offset + 10), + body_offset: 0, + body_len: 30, + } + } + + fn create_simple_module(func: FunctionAddressMap) -> ModuleAddressMap { + PrimaryMap::from_iter(vec![func]) + } + + #[test] + fn test_build_function_lookup_simple() { + let input = create_simple_func(11); + let (start, end, lookup) = build_function_lookup(&input, 1); + assert_eq!(10, start); + assert_eq!(20, end); + + assert_eq!(1, lookup.index.len()); + let index_entry = lookup.index.into_iter().next().unwrap(); + assert_eq!((10u64, vec![0].into_boxed_slice()), index_entry); + assert_eq!(1, lookup.ranges.len()); + let range = &lookup.ranges[0]; + assert_eq!(10, range.wasm_start); + assert_eq!(20, range.wasm_end); + assert_eq!(0, range.gen_start); + assert_eq!(30, range.gen_end); + let positions = &range.positions; + assert_eq!(2, positions.len()); + assert_eq!(12, positions[0].wasm_pos); + assert_eq!(5, positions[0].gen_start); + assert_eq!(8, positions[0].gen_end); + assert_eq!(17, positions[1].wasm_pos); + assert_eq!(15, positions[1].gen_start); + assert_eq!(23, positions[1].gen_end); + } + + #[test] + fn test_build_function_lookup_two_ranges() { + let mut input = create_simple_func(11); + // append instruction with same srcloc as input.instructions[0] + input.instructions.push(InstructionAddressMap { + srcloc: SourceLoc::new(11 + 2), + code_offset: 23, + code_len: 3, + }); + let (start, end, lookup) = build_function_lookup(&input, 1); + assert_eq!(10, start); + assert_eq!(20, end); + + assert_eq!(2, lookup.index.len()); + let index_entries = Vec::from_iter(lookup.index.into_iter()); + assert_eq!((10u64, vec![0].into_boxed_slice()), index_entries[0]); + assert_eq!((12u64, vec![0, 1].into_boxed_slice()), index_entries[1]); + assert_eq!(2, lookup.ranges.len()); + + let range = &lookup.ranges[0]; + assert_eq!(10, range.wasm_start); + assert_eq!(17, range.wasm_end); + assert_eq!(0, range.gen_start); + assert_eq!(23, range.gen_end); + let positions = &range.positions; + assert_eq!(2, positions.len()); + assert_eq!(12, positions[0].wasm_pos); + assert_eq!(5, positions[0].gen_start); + assert_eq!(8, positions[0].gen_end); + assert_eq!(17, positions[1].wasm_pos); + assert_eq!(15, positions[1].gen_start); + assert_eq!(23, positions[1].gen_end); + + let range = &lookup.ranges[1]; + assert_eq!(12, range.wasm_start); + assert_eq!(20, range.wasm_end); + assert_eq!(23, range.gen_start); + assert_eq!(30, range.gen_end); + let positions = &range.positions; + assert_eq!(1, positions.len()); + assert_eq!(12, positions[0].wasm_pos); + assert_eq!(23, positions[0].gen_start); + assert_eq!(26, positions[0].gen_end); + } + + #[test] + fn test_addr_translate() { + let input = create_simple_module(create_simple_func(11)); + let at = AddressTransform::new( + &input, + &WasmFileInfo { + path: None, + code_section_offset: 1, + funcs: Box::new([]), + }, + ); + + let addr = at.translate(10); + assert_eq!( + Some(Address::Symbol { + symbol: 0, + addend: 0, + }), + addr + ); + + let addr = at.translate(20); + assert_eq!( + Some(Address::Symbol { + symbol: 0, + addend: 30, + }), + addr + ); + + let addr = at.translate(0); + assert_eq!(None, addr); + + let addr = at.translate(12); + assert_eq!( + Some(Address::Symbol { + symbol: 0, + addend: 5, + }), + addr + ); + + let addr = at.translate(18); + assert_eq!( + Some(Address::Symbol { + symbol: 0, + addend: 23, + }), + addr + ); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +
+use super::address_transform::AddressTransform; +use super::expression::{compile_expression, CompiledExpression, FunctionFrameInfo}; +use super::range_info_builder::RangeInfoBuilder; +use super::refs::{PendingDebugInfoRefs, PendingUnitRefs}; +use super::{DebugInputContext, Reader, TransformError}; +use anyhow::Error; +use gimli::{write, AttributeValue, DebugLineOffset, DebugStr, DebuggingInformationEntry}; + +pub(crate) enum FileAttributeContext<'a> { + Root(Option<DebugLineOffset>), + Children(&'a Vec<write::FileId>, Option<&'a CompiledExpression>), +} + +fn is_exprloc_to_loclist_allowed(attr_name: gimli::constants::DwAt) -> bool { + match attr_name { + gimli::DW_AT_location + | gimli::DW_AT_string_length + | gimli::DW_AT_return_addr + | gimli::DW_AT_data_member_location + | gimli::DW_AT_frame_base + | gimli::DW_AT_segment + | gimli::DW_AT_static_link + | gimli::DW_AT_use_location + | gimli::DW_AT_vtable_elem_location => true, + _ => false, + } +} + +pub(crate) fn clone_die_attributes<'a, R>( + entry: &DebuggingInformationEntry<R>, + context: &DebugInputContext<R>, + addr_tr: &'a AddressTransform, + frame_info: Option<&FunctionFrameInfo>, + unit_encoding: gimli::Encoding, + out_unit: &mut write::Unit, + current_scope_id: write::UnitEntryId, + subprogram_range_builder: Option<RangeInfoBuilder>, + scope_ranges: Option<&Vec<(u64, u64)>>, + cu_low_pc: u64, + out_strings: &mut write::StringTable, + pending_die_refs: &mut PendingUnitRefs, + pending_di_refs: &mut PendingDebugInfoRefs, + file_context: FileAttributeContext<'a>, +) -> Result<(), Error> +where + R: Reader, +{ + let _tag = &entry.tag(); + let endian = gimli::RunTimeEndian::Little; + + let range_info = if let Some(subprogram_range_builder) = subprogram_range_builder { + subprogram_range_builder + } else if entry.tag() == gimli::DW_TAG_compile_unit { + // FIXME currently address_transform operate on a single func range, + // once it is fixed we can properly set DW_AT_ranges attribute. + // Using for now DW_AT_low_pc = 0. + RangeInfoBuilder::Position(0) + } else { + RangeInfoBuilder::from(entry, context, unit_encoding, cu_low_pc)? + }; + range_info.build(addr_tr, out_unit, current_scope_id); + + let mut attrs = entry.attrs(); + while let Some(attr) = attrs.next()? { + let attr_value = match attr.value() { + AttributeValue::Addr(_) if attr.name() == gimli::DW_AT_low_pc => { + continue; + } + AttributeValue::Udata(_) if attr.name() == gimli::DW_AT_high_pc => { + continue; + } + AttributeValue::RangeListsRef(_) if attr.name() == gimli::DW_AT_ranges => { + continue; + } + AttributeValue::Exprloc(_) if attr.name() == gimli::DW_AT_frame_base => { + continue; + } + + AttributeValue::Addr(u) => { + let addr = addr_tr.translate(u).unwrap_or(write::Address::Constant(0)); + write::AttributeValue::Address(addr) + } + AttributeValue::Udata(u) => write::AttributeValue::Udata(u), + AttributeValue::Data1(d) => write::AttributeValue::Data1(d), + AttributeValue::Data2(d) => write::AttributeValue::Data2(d), + AttributeValue::Data4(d) => write::AttributeValue::Data4(d), + AttributeValue::Sdata(d) => write::AttributeValue::Sdata(d), + AttributeValue::Flag(f) => write::AttributeValue::Flag(f), + AttributeValue::DebugLineRef(line_program_offset) => { + if let FileAttributeContext::Root(o) = file_context { + if o != Some(line_program_offset) { + return Err(TransformError("invalid debug_line offset").into()); + } + write::AttributeValue::LineProgramRef + } else { + return Err(TransformError("unexpected debug_line index attribute").into()); + } + } + AttributeValue::FileIndex(i) => { + if let FileAttributeContext::Children(file_map, _) = file_context { + write::AttributeValue::FileIndex(Some(file_map[(i - 1) as usize])) + } else { + return Err(TransformError("unexpected file index attribute").into()); + } + } + AttributeValue::DebugStrRef(str_offset) => { + let s = context.debug_str.get_str(str_offset)?.to_slice()?.to_vec(); + write::AttributeValue::StringRef(out_strings.add(s)) + } + AttributeValue::RangeListsRef(r) => { + let range_info = + RangeInfoBuilder::from_ranges_ref(r, context, unit_encoding, cu_low_pc)?; + let range_list_id = range_info.build_ranges(addr_tr, &mut out_unit.ranges); + write::AttributeValue::RangeListRef(range_list_id) + } + AttributeValue::LocationListsRef(r) => { + let low_pc = 0; + let mut locs = context.loclists.locations( + r, + unit_encoding, + low_pc, + &context.debug_addr, + context.debug_addr_base, + )?; + let frame_base = if let FileAttributeContext::Children(_, frame_base) = file_context + { + frame_base + } else { + None + }; + let mut result = None; + while let Some(loc) = locs.next()? { + if let Some(expr) = compile_expression(&loc.data, unit_encoding, frame_base)? { + if result.is_none() { + result = Some(Vec::new()); + } + for (start, len, expr) in expr.build_with_locals( + &[(loc.range.begin, loc.range.end)], + addr_tr, + frame_info, + endian, + ) { + if len == 0 { + // Ignore empty range + continue; + } + result.as_mut().unwrap().push(write::Location::StartLength { + begin: start, + length: len, + data: expr, + }); + } + } else { + // FIXME _expr contains invalid expression + continue; // ignore entry + } + } + if result.is_none() { + continue; // no valid locations + } + let list_id = out_unit.locations.add(write::LocationList(result.unwrap())); + write::AttributeValue::LocationListRef(list_id) + } + AttributeValue::Exprloc(ref expr) => { + let frame_base = if let FileAttributeContext::Children(_, frame_base) = file_context + { + frame_base + } else { + None + }; + if let Some(expr) = compile_expression(expr, unit_encoding, frame_base)? { + if expr.is_simple() { + if let Some(expr) = expr.build() { + write::AttributeValue::Exprloc(expr) + } else { + continue; + } + } else { + // Conversion to loclist is required. + if let Some(scope_ranges) = scope_ranges { + let exprs = + expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian); + if exprs.is_empty() { + continue; + } + let found_single_expr = { + // Micro-optimization all expressions alike, use one exprloc. + let mut found_expr: Option<write::Expression> = None; + for (_, _, expr) in &exprs { + if let Some(ref prev_expr) = found_expr { + if expr.0.eq(&prev_expr.0) { + continue; // the same expression + } + found_expr = None; + break; + } + found_expr = Some(expr.clone()) + } + found_expr + }; + if let Some(expr) = found_single_expr { + write::AttributeValue::Exprloc(expr) + } else if is_exprloc_to_loclist_allowed(attr.name()) { + // Converting exprloc to loclist. + let mut locs = Vec::new(); + for (begin, length, data) in exprs { + if length == 0 { + // Ignore empty range + continue; + } + locs.push(write::Location::StartLength { + begin, + length, + data, + }); + } + let list_id = out_unit.locations.add(write::LocationList(locs)); + write::AttributeValue::LocationListRef(list_id) + } else { + continue; + } + } else { + continue; + } + } + } else { + // FIXME _expr contains invalid expression + continue; // ignore attribute + } + } + AttributeValue::Encoding(e) => write::AttributeValue::Encoding(e), + AttributeValue::DecimalSign(e) => write::AttributeValue::DecimalSign(e), + AttributeValue::Endianity(e) => write::AttributeValue::Endianity(e), + AttributeValue::Accessibility(e) => write::AttributeValue::Accessibility(e), + AttributeValue::Visibility(e) => write::AttributeValue::Visibility(e), + AttributeValue::Virtuality(e) => write::AttributeValue::Virtuality(e), + AttributeValue::Language(e) => write::AttributeValue::Language(e), + AttributeValue::AddressClass(e) => write::AttributeValue::AddressClass(e), + AttributeValue::IdentifierCase(e) => write::AttributeValue::IdentifierCase(e), + AttributeValue::CallingConvention(e) => write::AttributeValue::CallingConvention(e), + AttributeValue::Inline(e) => write::AttributeValue::Inline(e), + AttributeValue::Ordering(e) => write::AttributeValue::Ordering(e), + AttributeValue::UnitRef(offset) => { + pending_die_refs.insert(current_scope_id, attr.name(), offset); + continue; + } + AttributeValue::DebugInfoRef(offset) => { + pending_di_refs.insert(current_scope_id, attr.name(), offset); + continue; + } + _ => panic!(), //write::AttributeValue::StringRef(out_strings.add("_")), + }; + let current_scope = out_unit.get_mut(current_scope_id); + current_scope.set(attr.name(), attr_value); + } + Ok(()) +} + +pub(crate) fn clone_attr_string<R>( + attr_value: &AttributeValue<R>, + form: gimli::DwForm, + debug_str: &DebugStr<R>, + out_strings: &mut write::StringTable, +) -> Result<write::LineString, gimli::Error> +where + R: Reader, +{ + let content = match attr_value { + AttributeValue::DebugStrRef(str_offset) => { + debug_str.get_str(*str_offset)?.to_slice()?.to_vec() + } + AttributeValue::String(b) => b.to_slice()?.to_vec(), + _ => panic!("Unexpected attribute value"), + }; + Ok(match form { + gimli::DW_FORM_strp => { + let id = out_strings.add(content); + write::LineString::StringRef(id) + } + gimli::DW_FORM_string => write::LineString::String(content), + _ => panic!("DW_FORM_line_strp or other not supported"), + }) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +
+use super::address_transform::AddressTransform; +use anyhow::Error; +use gimli::{self, write, Expression, Operation, Reader, ReaderOffset, Register, X86_64}; +use more_asserts::{assert_le, assert_lt}; +use std::collections::{HashMap, HashSet}; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::ir::{StackSlots, ValueLabel, ValueLabelsRanges, ValueLoc}; +use wasmtime_environ::isa::RegUnit; +use wasmtime_environ::wasm::{get_vmctx_value_label, DefinedFuncIndex}; +use wasmtime_environ::ModuleMemoryOffset; + +#[derive(Debug)] +pub struct FunctionFrameInfo<'a> { + pub value_ranges: &'a ValueLabelsRanges, + pub memory_offset: ModuleMemoryOffset, + pub stack_slots: &'a StackSlots, +} + +impl<'a> FunctionFrameInfo<'a> { + fn vmctx_memory_offset(&self) -> Option<i64> { + match self.memory_offset { + ModuleMemoryOffset::Defined(x) => Some(x as i64), + ModuleMemoryOffset::Imported(_) => { + // TODO implement memory offset for imported memory + None + } + ModuleMemoryOffset::None => None, + } + } +} + +#[derive(Debug)] +enum CompiledExpressionPart { + Code(Vec<u8>), + Local(ValueLabel), + Deref, +} + +#[derive(Debug)] +pub struct CompiledExpression { + parts: Vec<CompiledExpressionPart>, + need_deref: bool, +} + +impl Clone for CompiledExpressionPart { + fn clone(&self) -> Self { + match self { + CompiledExpressionPart::Code(c) => CompiledExpressionPart::Code(c.clone()), + CompiledExpressionPart::Local(i) => CompiledExpressionPart::Local(*i), + CompiledExpressionPart::Deref => CompiledExpressionPart::Deref, + } + } +} + +impl CompiledExpression { + pub fn vmctx() -> CompiledExpression { + CompiledExpression::from_label(get_vmctx_value_label()) + } + + pub fn from_label(label: ValueLabel) -> CompiledExpression { + CompiledExpression { + parts: vec![ + CompiledExpressionPart::Local(label), + CompiledExpressionPart::Code(vec![gimli::constants::DW_OP_stack_value.0 as u8]), + ], + need_deref: false, + } + } +} + +fn map_reg(reg: RegUnit) -> Register { + static mut REG_X86_MAP: Option<HashMap<RegUnit, Register>> = None; + // FIXME lazy initialization? + unsafe { + if REG_X86_MAP.is_none() { + REG_X86_MAP = Some(HashMap::new()); + } + if let Some(val) = REG_X86_MAP.as_mut().unwrap().get(®) { + return *val; + } + let result = match reg { + 0 => X86_64::RAX, + 1 => X86_64::RCX, + 2 => X86_64::RDX, + 3 => X86_64::RBX, + 4 => X86_64::RSP, + 5 => X86_64::RBP, + 6 => X86_64::RSI, + 7 => X86_64::RDI, + 8 => X86_64::R8, + 9 => X86_64::R9, + 10 => X86_64::R10, + 11 => X86_64::R11, + 12 => X86_64::R12, + 13 => X86_64::R13, + 14 => X86_64::R14, + 15 => X86_64::R15, + 16 => X86_64::XMM0, + 17 => X86_64::XMM1, + 18 => X86_64::XMM2, + 19 => X86_64::XMM3, + 20 => X86_64::XMM4, + 21 => X86_64::XMM5, + 22 => X86_64::XMM6, + 23 => X86_64::XMM7, + 24 => X86_64::XMM8, + 25 => X86_64::XMM9, + 26 => X86_64::XMM10, + 27 => X86_64::XMM11, + 28 => X86_64::XMM12, + 29 => X86_64::XMM13, + 30 => X86_64::XMM14, + 31 => X86_64::XMM15, + _ => panic!("unknown x86_64 register {}", reg), + }; + REG_X86_MAP.as_mut().unwrap().insert(reg, result); + result + } +} + +fn translate_loc(loc: ValueLoc, frame_info: Option<&FunctionFrameInfo>) -> Option<Vec<u8>> { + use gimli::write::Writer; + match loc { + ValueLoc::Reg(reg) => { + let machine_reg = map_reg(reg).0 as u8; + Some(if machine_reg < 32 { + vec![gimli::constants::DW_OP_reg0.0 + machine_reg] + } else { + let endian = gimli::RunTimeEndian::Little; + let mut writer = write::EndianVec::new(endian); + writer + .write_u8(gimli::constants::DW_OP_regx.0 as u8) + .expect("regx"); + writer + .write_uleb128(machine_reg.into()) + .expect("machine_reg"); + writer.into_vec() + }) + } + ValueLoc::Stack(ss) => { + if let Some(frame_info) = frame_info { + if let Some(ss_offset) = frame_info.stack_slots[ss].offset { + let endian = gimli::RunTimeEndian::Little; + let mut writer = write::EndianVec::new(endian); + writer + .write_u8(gimli::constants::DW_OP_breg0.0 + X86_64::RBP.0 as u8) + .expect("bp wr"); + writer.write_sleb128(ss_offset as i64 + 16).expect("ss wr"); + writer + .write_u8(gimli::constants::DW_OP_deref.0 as u8) + .expect("bp wr"); + let buf = writer.into_vec(); + return Some(buf); + } + } + None + } + _ => None, + } +} + +fn append_memory_deref( + buf: &mut Vec<u8>, + frame_info: &FunctionFrameInfo, + vmctx_loc: ValueLoc, + endian: gimli::RunTimeEndian, +) -> write::Result<bool> { + use gimli::write::Writer; + let mut writer = write::EndianVec::new(endian); + // FIXME for imported memory + match vmctx_loc { + ValueLoc::Reg(vmctx_reg) => { + let reg = map_reg(vmctx_reg); + writer.write_u8(gimli::constants::DW_OP_breg0.0 + reg.0 as u8)?; + let memory_offset = match frame_info.vmctx_memory_offset() { + Some(offset) => offset, + None => { + return Ok(false); + } + }; + writer.write_sleb128(memory_offset)?; + } + ValueLoc::Stack(ss) => { + if let Some(ss_offset) = frame_info.stack_slots[ss].offset { + writer.write_u8(gimli::constants::DW_OP_breg0.0 + X86_64::RBP.0 as u8)?; + writer.write_sleb128(ss_offset as i64 + 16)?; + writer.write_u8(gimli::constants::DW_OP_deref.0 as u8)?; + writer.write_u8(gimli::constants::DW_OP_consts.0 as u8)?; + let memory_offset = match frame_info.vmctx_memory_offset() { + Some(offset) => offset, + None => { + return Ok(false); + } + }; + writer.write_sleb128(memory_offset)?; + writer.write_u8(gimli::constants::DW_OP_plus.0 as u8)?; + } else { + return Ok(false); + } + } + _ => { + return Ok(false); + } + } + writer.write_u8(gimli::constants::DW_OP_deref.0 as u8)?; + writer.write_u8(gimli::constants::DW_OP_swap.0 as u8)?; + writer.write_u8(gimli::constants::DW_OP_stack_value.0 as u8)?; + writer.write_u8(gimli::constants::DW_OP_constu.0 as u8)?; + writer.write_uleb128(0xffff_ffff)?; + writer.write_u8(gimli::constants::DW_OP_and.0 as u8)?; + writer.write_u8(gimli::constants::DW_OP_plus.0 as u8)?; + buf.extend_from_slice(writer.slice()); + Ok(true) +} + +impl CompiledExpression { + pub fn is_simple(&self) -> bool { + if let [CompiledExpressionPart::Code(_)] = self.parts.as_slice() { + true + } else { + self.parts.is_empty() + } + } + + pub fn build(&self) -> Option<write::Expression> { + if let [CompiledExpressionPart::Code(code)] = self.parts.as_slice() { + return Some(write::Expression(code.to_vec())); + } + // locals found, not supported + None + } + + pub fn build_with_locals( + &self, + scope: &[(u64, u64)], // wasm ranges + addr_tr: &AddressTransform, + frame_info: Option<&FunctionFrameInfo>, + endian: gimli::RunTimeEndian, + ) -> Vec<(write::Address, u64, write::Expression)> { + if scope.is_empty() { + return vec![]; + } + + if let [CompiledExpressionPart::Code(code)] = self.parts.as_slice() { + let mut result_scope = Vec::new(); + for s in scope { + for (addr, len) in addr_tr.translate_ranges(s.0, s.1) { + result_scope.push((addr, len, write::Expression(code.to_vec()))); + } + } + return result_scope; + } + + let vmctx_label = get_vmctx_value_label(); + + // Some locals are present, preparing and divided ranges based on the scope + // and frame_info data. + let mut ranges_builder = ValueLabelRangesBuilder::new(scope, addr_tr, frame_info); + for p in &self.parts { + match p { + CompiledExpressionPart::Code(_) => (), + CompiledExpressionPart::Local(label) => ranges_builder.process_label(*label), + CompiledExpressionPart::Deref => ranges_builder.process_label(vmctx_label), + } + } + if self.need_deref { + ranges_builder.process_label(vmctx_label); + } + ranges_builder.remove_incomplete_ranges(); + let ranges = ranges_builder.ranges; + + let mut result = Vec::new(); + 'range: for CachedValueLabelRange { + func_index, + start, + end, + label_location, + } in ranges + { + // build expression + let mut code_buf = Vec::new(); + for part in &self.parts { + match part { + CompiledExpressionPart::Code(c) => code_buf.extend_from_slice(c.as_slice()), + CompiledExpressionPart::Local(label) => { + let loc = *label_location.get(&label).expect("loc"); + if let Some(expr) = translate_loc(loc, frame_info) { + code_buf.extend_from_slice(&expr) + } else { + continue 'range; + } + } + CompiledExpressionPart::Deref => { + if let (Some(vmctx_loc), Some(frame_info)) = + (label_location.get(&vmctx_label), frame_info) + { + if !append_memory_deref(&mut code_buf, frame_info, *vmctx_loc, endian) + .expect("append_memory_deref") + { + continue 'range; + } + } else { + continue 'range; + }; + } + } + } + if self.need_deref { + if let (Some(vmctx_loc), Some(frame_info)) = + (label_location.get(&vmctx_label), frame_info) + { + if !append_memory_deref(&mut code_buf, frame_info, *vmctx_loc, endian) + .expect("append_memory_deref") + { + continue 'range; + } + } else { + continue 'range; + }; + } + result.push(( + write::Address::Symbol { + symbol: func_index.index(), + addend: start as i64, + }, + (end - start) as u64, + write::Expression(code_buf), + )); + } + + result + } +} + +fn is_old_expression_format(buf: &[u8]) -> bool { + // Heuristic to detect old variable expression format without DW_OP_fbreg: + // DW_OP_plus_uconst op must be present, but not DW_OP_fbreg. + if buf.contains(&(gimli::constants::DW_OP_fbreg.0 as u8)) { + // Stop check if DW_OP_fbreg exist. + return false; + } + buf.contains(&(gimli::constants::DW_OP_plus_uconst.0 as u8)) +} + +pub fn compile_expression<R>( + expr: &Expression<R>, + encoding: gimli::Encoding, + frame_base: Option<&CompiledExpression>, +) -> Result<Option<CompiledExpression>, Error> +where + R: Reader, +{ + let mut pc = expr.0.clone(); + let buf = expr.0.to_slice()?; + let mut parts = Vec::new(); + let mut need_deref = false; + if is_old_expression_format(&buf) && frame_base.is_some() { + // Still supporting old DWARF variable expressions without fbreg. + parts.extend_from_slice(&frame_base.unwrap().parts); + need_deref = frame_base.unwrap().need_deref; + } + let base_len = parts.len(); + let mut code_chunk = Vec::new(); + while !pc.is_empty() { + let next = buf[pc.offset_from(&expr.0).into_u64() as usize]; + need_deref = true; + if next == 0xED { + // WebAssembly DWARF extension + pc.read_u8()?; + let ty = pc.read_uleb128()?; + assert_eq!(ty, 0); + let index = pc.read_sleb128()?; + pc.read_u8()?; // consume 159 + if !code_chunk.is_empty() { + parts.push(CompiledExpressionPart::Code(code_chunk)); + code_chunk = Vec::new(); + } + let label = ValueLabel::from_u32(index as u32); + parts.push(CompiledExpressionPart::Local(label)); + } else { + let pos = pc.offset_from(&expr.0).into_u64() as usize; + let op = Operation::parse(&mut pc, &expr.0, encoding)?; + match op { + Operation::FrameOffset { offset } => { + // Expand DW_OP_fpreg into frame location and DW_OP_plus_uconst. + use gimli::write::Writer; + if frame_base.is_some() { + // Add frame base expressions. + if !code_chunk.is_empty() { + parts.push(CompiledExpressionPart::Code(code_chunk)); + code_chunk = Vec::new(); + } + parts.extend_from_slice(&frame_base.unwrap().parts); + need_deref = frame_base.unwrap().need_deref; + } + // Append DW_OP_plus_uconst part. + let endian = gimli::RunTimeEndian::Little; + let mut writer = write::EndianVec::new(endian); + writer.write_u8(gimli::constants::DW_OP_plus_uconst.0 as u8)?; + writer.write_uleb128(offset as u64)?; + code_chunk.extend(writer.into_vec()); + continue; + } + Operation::Literal { .. } | Operation::PlusConstant { .. } => (), + Operation::StackValue => { + need_deref = false; + } + Operation::Deref { .. } => { + if !code_chunk.is_empty() { + parts.push(CompiledExpressionPart::Code(code_chunk)); + code_chunk = Vec::new(); + } + parts.push(CompiledExpressionPart::Deref); + } + _ => { + return Ok(None); + } + } + let chunk = &buf[pos..pc.offset_from(&expr.0).into_u64() as usize]; + code_chunk.extend_from_slice(chunk); + } + } + + if !code_chunk.is_empty() { + parts.push(CompiledExpressionPart::Code(code_chunk)); + } + + if base_len > 0 && base_len + 1 < parts.len() { + // see if we can glue two code chunks + if let [CompiledExpressionPart::Code(cc1), CompiledExpressionPart::Code(cc2)] = + &parts[base_len..=base_len] + { + let mut combined = cc1.clone(); + combined.extend_from_slice(cc2); + parts[base_len] = CompiledExpressionPart::Code(combined); + parts.remove(base_len + 1); + } + } + + Ok(Some(CompiledExpression { parts, need_deref })) +} + +#[derive(Debug, Clone)] +struct CachedValueLabelRange { + func_index: DefinedFuncIndex, + start: usize, + end: usize, + label_location: HashMap<ValueLabel, ValueLoc>, +} + +struct ValueLabelRangesBuilder<'a, 'b> { + ranges: Vec<CachedValueLabelRange>, + addr_tr: &'a AddressTransform, + frame_info: Option<&'a FunctionFrameInfo<'b>>, + processed_labels: HashSet<ValueLabel>, +} + +impl<'a, 'b> ValueLabelRangesBuilder<'a, 'b> { + fn new( + scope: &[(u64, u64)], // wasm ranges + addr_tr: &'a AddressTransform, + frame_info: Option<&'a FunctionFrameInfo<'b>>, + ) -> Self { + let mut ranges = Vec::new(); + for s in scope { + if let Some((func_index, tr)) = addr_tr.translate_ranges_raw(s.0, s.1) { + for (start, end) in tr { + ranges.push(CachedValueLabelRange { + func_index, + start, + end, + label_location: HashMap::new(), + }) + } + } + } + ranges.sort_unstable_by(|a, b| a.start.cmp(&b.start)); + ValueLabelRangesBuilder { + ranges, + addr_tr, + frame_info, + processed_labels: HashSet::new(), + } + } + + fn process_label(&mut self, label: ValueLabel) { + if self.processed_labels.contains(&label) { + return; + } + self.processed_labels.insert(label); + + let value_ranges = if let Some(frame_info) = self.frame_info { + &frame_info.value_ranges + } else { + return; + }; + + let ranges = &mut self.ranges; + if let Some(local_ranges) = value_ranges.get(&label) { + for local_range in local_ranges { + let wasm_start = local_range.start; + let wasm_end = local_range.end; + let loc = local_range.loc; + // Find all native ranges for the value label ranges. + for (addr, len) in self + .addr_tr + .translate_ranges(wasm_start as u64, wasm_end as u64) + { + let (range_start, range_end) = self.addr_tr.convert_to_code_range(addr, len); + if range_start == range_end { + continue; + } + assert_lt!(range_start, range_end); + // Find acceptable scope of ranges to intersect with. + let i = match ranges.binary_search_by(|s| s.start.cmp(&range_start)) { + Ok(i) => i, + Err(i) => { + if i > 0 && range_start < ranges[i - 1].end { + i - 1 + } else { + i + } + } + }; + let j = match ranges.binary_search_by(|s| s.start.cmp(&range_end)) { + Ok(i) | Err(i) => i, + }; + // Starting for the end, intersect (range_start..range_end) with + // self.ranges array. + for i in (i..j).rev() { + if range_end <= ranges[i].start || ranges[i].end <= range_start { + continue; + } + if range_end < ranges[i].end { + // Cutting some of the range from the end. + let mut tail = ranges[i].clone(); + ranges[i].end = range_end; + tail.start = range_end; + ranges.insert(i + 1, tail); + } + assert_le!(ranges[i].end, range_end); + if range_start <= ranges[i].start { + ranges[i].label_location.insert(label, loc); + continue; + } + // Cutting some of the range from the start. + let mut tail = ranges[i].clone(); + ranges[i].end = range_start; + tail.start = range_start; + tail.label_location.insert(label, loc); + ranges.insert(i + 1, tail); + } + } + } + } + } + + fn remove_incomplete_ranges(&mut self) { + // Ranges with not-enough labels are discarded. + let processed_labels_len = self.processed_labels.len(); + self.ranges + .retain(|r| r.label_location.len() == processed_labels_len); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +
+use super::address_transform::AddressTransform; +use super::attr::clone_attr_string; +use super::{Reader, TransformError}; +use anyhow::Error; +use gimli::{ + write, DebugLine, DebugLineOffset, DebugStr, DebuggingInformationEntry, LineEncoding, Unit, +}; +use more_asserts::assert_le; +use std::collections::BTreeMap; +use std::iter::FromIterator; +use wasmtime_environ::entity::EntityRef; + +#[derive(Debug)] +enum SavedLineProgramRow { + Normal { + address: u64, + op_index: u64, + file_index: u64, + line: u64, + column: u64, + discriminator: u64, + is_stmt: bool, + basic_block: bool, + prologue_end: bool, + epilogue_begin: bool, + isa: u64, + }, + EndOfSequence(u64), +} + +#[derive(Debug, Eq, PartialEq)] +enum ReadLineProgramState { + SequenceEnded, + ReadSequence, + IgnoreSequence, +} + +pub(crate) fn clone_line_program<R>( + unit: &Unit<R, R::Offset>, + root: &DebuggingInformationEntry<R>, + addr_tr: &AddressTransform, + out_encoding: gimli::Encoding, + debug_str: &DebugStr<R>, + debug_line: &DebugLine<R>, + out_strings: &mut write::StringTable, +) -> Result<(write::LineProgram, DebugLineOffset, Vec<write::FileId>), Error> +where + R: Reader, +{ + let offset = match root.attr_value(gimli::DW_AT_stmt_list)? { + Some(gimli::AttributeValue::DebugLineRef(offset)) => offset, + _ => { + return Err(TransformError("Debug line offset is not found").into()); + } + }; + let comp_dir = root.attr_value(gimli::DW_AT_comp_dir)?; + let comp_name = root.attr_value(gimli::DW_AT_name)?; + let out_comp_dir = clone_attr_string( + comp_dir.as_ref().expect("comp_dir"), + gimli::DW_FORM_strp, + debug_str, + out_strings, + )?; + let out_comp_name = clone_attr_string( + comp_name.as_ref().expect("comp_name"), + gimli::DW_FORM_strp, + debug_str, + out_strings, + )?; + + let program = debug_line.program( + offset, + unit.header.address_size(), + comp_dir.and_then(|val| val.string_value(&debug_str)), + comp_name.and_then(|val| val.string_value(&debug_str)), + ); + if let Ok(program) = program { + let header = program.header(); + assert_le!(header.version(), 4, "not supported 5"); + let line_encoding = LineEncoding { + minimum_instruction_length: header.minimum_instruction_length(), + maximum_operations_per_instruction: header.maximum_operations_per_instruction(), + default_is_stmt: header.default_is_stmt(), + line_base: header.line_base(), + line_range: header.line_range(), + }; + let mut out_program = write::LineProgram::new( + out_encoding, + line_encoding, + out_comp_dir, + out_comp_name, + None, + ); + let mut dirs = Vec::new(); + dirs.push(out_program.default_directory()); + for dir_attr in header.include_directories() { + let dir_id = out_program.add_directory(clone_attr_string( + dir_attr, + gimli::DW_FORM_string, + debug_str, + out_strings, + )?); + dirs.push(dir_id); + } + let mut files = Vec::new(); + for file_entry in header.file_names() { + let dir_id = dirs[file_entry.directory_index() as usize]; + let file_id = out_program.add_file( + clone_attr_string( + &file_entry.path_name(), + gimli::DW_FORM_string, + debug_str, + out_strings, + )?, + dir_id, + None, + ); + files.push(file_id); + } + + let mut rows = program.rows(); + let mut saved_rows = BTreeMap::new(); + let mut state = ReadLineProgramState::SequenceEnded; + while let Some((_header, row)) = rows.next_row()? { + if state == ReadLineProgramState::IgnoreSequence { + if row.end_sequence() { + state = ReadLineProgramState::SequenceEnded; + } + continue; + } + let saved_row = if row.end_sequence() { + state = ReadLineProgramState::SequenceEnded; + SavedLineProgramRow::EndOfSequence(row.address()) + } else { + if state == ReadLineProgramState::SequenceEnded { + // Discard sequences for non-existent code. + if row.address() == 0 { + state = ReadLineProgramState::IgnoreSequence; + continue; + } + state = ReadLineProgramState::ReadSequence; + } + SavedLineProgramRow::Normal { + address: row.address(), + op_index: row.op_index(), + file_index: row.file_index(), + line: row.line().unwrap_or(0), + column: match row.column() { + gimli::ColumnType::LeftEdge => 0, + gimli::ColumnType::Column(val) => val, + }, + discriminator: row.discriminator(), + is_stmt: row.is_stmt(), + basic_block: row.basic_block(), + prologue_end: row.prologue_end(), + epilogue_begin: row.epilogue_begin(), + isa: row.isa(), + } + }; + saved_rows.insert(row.address(), saved_row); + } + + let saved_rows = Vec::from_iter(saved_rows.into_iter()); + for (i, map) in addr_tr.map() { + if map.len == 0 { + continue; // no code generated + } + let symbol = i.index(); + let base_addr = map.offset; + out_program.begin_sequence(Some(write::Address::Symbol { symbol, addend: 0 })); + // TODO track and place function declaration line here + let mut last_address = None; + for addr_map in map.addresses.iter() { + let saved_row = match saved_rows.binary_search_by_key(&addr_map.wasm, |i| i.0) { + Ok(i) => Some(&saved_rows[i].1), + Err(i) => { + if i > 0 { + Some(&saved_rows[i - 1].1) + } else { + None + } + } + }; + if let Some(SavedLineProgramRow::Normal { + address, + op_index, + file_index, + line, + column, + discriminator, + is_stmt, + basic_block, + prologue_end, + epilogue_begin, + isa, + }) = saved_row + { + // Ignore duplicates + if Some(*address) != last_address { + let address_offset = if last_address.is_none() { + // Extend first entry to the function declaration + // TODO use the function declaration line instead + 0 + } else { + (addr_map.generated - base_addr) as u64 + }; + out_program.row().address_offset = address_offset; + out_program.row().op_index = *op_index; + out_program.row().file = files[(file_index - 1) as usize]; + out_program.row().line = *line; + out_program.row().column = *column; + out_program.row().discriminator = *discriminator; + out_program.row().is_statement = *is_stmt; + out_program.row().basic_block = *basic_block; + out_program.row().prologue_end = *prologue_end; + out_program.row().epilogue_begin = *epilogue_begin; + out_program.row().isa = *isa; + out_program.generate_row(); + last_address = Some(*address); + } + } + } + let end_addr = (map.offset + map.len - 1) as u64; + out_program.end_sequence(end_addr); + } + Ok((out_program, offset, files)) + } else { + Err(TransformError("Valid line program not found").into()) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +
+use self::refs::DebugInfoRefsMap; +use self::simulate::generate_simulated_dwarf; +use self::unit::clone_unit; +use crate::gc::build_dependencies; +use crate::DebugInfoData; +use anyhow::Error; +use gimli::{ + write, DebugAddr, DebugAddrBase, DebugLine, DebugStr, LocationLists, RangeLists, + UnitSectionOffset, +}; +use std::collections::HashSet; +use thiserror::Error; +use wasmtime_environ::isa::TargetFrontendConfig; +use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges}; + +pub use address_transform::AddressTransform; + +mod address_transform; +mod attr; +mod expression; +mod line_program; +mod range_info_builder; +mod refs; +mod simulate; +mod unit; +mod utils; + +pub(crate) trait Reader: gimli::Reader<Offset = usize> {} + +impl<'input, Endian> Reader for gimli::EndianSlice<'input, Endian> where Endian: gimli::Endianity {} + +#[derive(Error, Debug)] +#[error("Debug info transform error: {0}")] +pub struct TransformError(&'static str); + +pub(crate) struct DebugInputContext<'a, R> +where + R: Reader, +{ + debug_str: &'a DebugStr<R>, + debug_line: &'a DebugLine<R>, + debug_addr: &'a DebugAddr<R>, + debug_addr_base: DebugAddrBase<R::Offset>, + rnglists: &'a RangeLists<R>, + loclists: &'a LocationLists<R>, + reachable: &'a HashSet<UnitSectionOffset>, +} + +pub fn transform_dwarf( + target_config: TargetFrontendConfig, + di: &DebugInfoData, + at: &ModuleAddressMap, + vmctx_info: &ModuleVmctxInfo, + ranges: &ValueLabelsRanges, +) -> Result<write::Dwarf, Error> { + let addr_tr = AddressTransform::new(at, &di.wasm_file); + let reachable = build_dependencies(&di.dwarf, &addr_tr)?.get_reachable(); + + let context = DebugInputContext { + debug_str: &di.dwarf.debug_str, + debug_line: &di.dwarf.debug_line, + debug_addr: &di.dwarf.debug_addr, + debug_addr_base: DebugAddrBase(0), + rnglists: &di.dwarf.ranges, + loclists: &di.dwarf.locations, + reachable: &reachable, + }; + + let out_encoding = gimli::Encoding { + format: gimli::Format::Dwarf32, + // TODO: this should be configurable + // macOS doesn't seem to support DWARF > 3 + version: 3, + address_size: target_config.pointer_bytes(), + }; + + let mut out_strings = write::StringTable::default(); + let mut out_units = write::UnitTable::default(); + + let out_line_strings = write::LineStringTable::default(); + let mut pending_di_refs = Vec::new(); + let mut di_ref_map = DebugInfoRefsMap::new(); + + let mut translated = HashSet::new(); + let mut iter = di.dwarf.debug_info.units(); + while let Some(header) = iter.next().unwrap_or(None) { + let unit = di.dwarf.unit(header)?; + if let Some((id, ref_map, pending_refs)) = clone_unit( + unit, + &context, + &addr_tr, + &ranges, + out_encoding, + &vmctx_info, + &mut out_units, + &mut out_strings, + &mut translated, + )? { + di_ref_map.insert(&header, id, ref_map); + pending_di_refs.push((id, pending_refs)); + } + } + di_ref_map.patch(pending_di_refs.into_iter(), &mut out_units); + + generate_simulated_dwarf( + &addr_tr, + di, + &vmctx_info, + &ranges, + &translated, + out_encoding, + &mut out_units, + &mut out_strings, + )?; + + Ok(write::Dwarf { + units: out_units, + line_programs: vec![], + line_strings: out_line_strings, + strings: out_strings, + }) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +
+use super::address_transform::AddressTransform; +use super::{DebugInputContext, Reader}; +use anyhow::Error; +use gimli::{write, AttributeValue, DebuggingInformationEntry, RangeListsOffset}; +use more_asserts::assert_lt; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::wasm::DefinedFuncIndex; + +pub(crate) enum RangeInfoBuilder { + Undefined, + Position(u64), + Ranges(Vec<(u64, u64)>), + Function(DefinedFuncIndex), +} + +impl RangeInfoBuilder { + pub(crate) fn from<R>( + entry: &DebuggingInformationEntry<R>, + context: &DebugInputContext<R>, + unit_encoding: gimli::Encoding, + cu_low_pc: u64, + ) -> Result<Self, Error> + where + R: Reader, + { + if let Some(AttributeValue::RangeListsRef(r)) = entry.attr_value(gimli::DW_AT_ranges)? { + return RangeInfoBuilder::from_ranges_ref(r, context, unit_encoding, cu_low_pc); + }; + + let low_pc = + if let Some(AttributeValue::Addr(addr)) = entry.attr_value(gimli::DW_AT_low_pc)? { + addr + } else { + return Ok(RangeInfoBuilder::Undefined); + }; + + Ok( + if let Some(AttributeValue::Udata(u)) = entry.attr_value(gimli::DW_AT_high_pc)? { + RangeInfoBuilder::Ranges(vec![(low_pc, low_pc + u)]) + } else { + RangeInfoBuilder::Position(low_pc) + }, + ) + } + + pub(crate) fn from_ranges_ref<R>( + ranges: RangeListsOffset, + context: &DebugInputContext<R>, + unit_encoding: gimli::Encoding, + cu_low_pc: u64, + ) -> Result<Self, Error> + where + R: Reader, + { + let mut ranges = context.rnglists.ranges( + ranges, + unit_encoding, + cu_low_pc, + &context.debug_addr, + context.debug_addr_base, + )?; + let mut result = Vec::new(); + while let Some(range) = ranges.next()? { + if range.begin >= range.end { + // ignore empty ranges + } + result.push((range.begin, range.end)); + } + + Ok(if result.is_empty() { + RangeInfoBuilder::Undefined + } else { + RangeInfoBuilder::Ranges(result) + }) + } + + pub(crate) fn from_subprogram_die<R>( + entry: &DebuggingInformationEntry<R>, + context: &DebugInputContext<R>, + unit_encoding: gimli::Encoding, + addr_tr: &AddressTransform, + cu_low_pc: u64, + ) -> Result<Self, Error> + where + R: Reader, + { + let addr = + if let Some(AttributeValue::Addr(addr)) = entry.attr_value(gimli::DW_AT_low_pc)? { + addr + } else if let Some(AttributeValue::RangeListsRef(r)) = + entry.attr_value(gimli::DW_AT_ranges)? + { + let mut ranges = context.rnglists.ranges( + r, + unit_encoding, + cu_low_pc, + &context.debug_addr, + context.debug_addr_base, + )?; + if let Some(range) = ranges.next()? { + range.begin + } else { + return Ok(RangeInfoBuilder::Undefined); + } + } else { + return Ok(RangeInfoBuilder::Undefined); + }; + + let index = addr_tr.find_func_index(addr); + if index.is_none() { + return Ok(RangeInfoBuilder::Undefined); + } + Ok(RangeInfoBuilder::Function(index.unwrap())) + } + + pub(crate) fn build( + &self, + addr_tr: &AddressTransform, + out_unit: &mut write::Unit, + current_scope_id: write::UnitEntryId, + ) { + match self { + RangeInfoBuilder::Undefined => (), + RangeInfoBuilder::Position(pc) => { + let addr = addr_tr + .translate(*pc) + .unwrap_or(write::Address::Constant(0)); + let current_scope = out_unit.get_mut(current_scope_id); + current_scope.set(gimli::DW_AT_low_pc, write::AttributeValue::Address(addr)); + } + RangeInfoBuilder::Ranges(ranges) => { + let mut result = Vec::new(); + for (begin, end) in ranges { + for tr in addr_tr.translate_ranges(*begin, *end) { + if tr.1 == 0 { + // Ignore empty range + continue; + } + result.push(tr); + } + } + if result.len() != 1 { + let range_list = result + .iter() + .map(|tr| write::Range::StartLength { + begin: tr.0, + length: tr.1, + }) + .collect::<Vec<_>>(); + let range_list_id = out_unit.ranges.add(write::RangeList(range_list)); + let current_scope = out_unit.get_mut(current_scope_id); + current_scope.set( + gimli::DW_AT_ranges, + write::AttributeValue::RangeListRef(range_list_id), + ); + } else { + let current_scope = out_unit.get_mut(current_scope_id); + current_scope.set( + gimli::DW_AT_low_pc, + write::AttributeValue::Address(result[0].0), + ); + current_scope.set( + gimli::DW_AT_high_pc, + write::AttributeValue::Udata(result[0].1), + ); + } + } + RangeInfoBuilder::Function(index) => { + let range = addr_tr.func_range(*index); + let symbol = index.index(); + let addr = write::Address::Symbol { + symbol, + addend: range.0 as i64, + }; + let len = (range.1 - range.0) as u64; + let current_scope = out_unit.get_mut(current_scope_id); + current_scope.set(gimli::DW_AT_low_pc, write::AttributeValue::Address(addr)); + current_scope.set(gimli::DW_AT_high_pc, write::AttributeValue::Udata(len)); + } + } + } + + pub(crate) fn get_ranges(&self, addr_tr: &AddressTransform) -> Vec<(u64, u64)> { + match self { + RangeInfoBuilder::Undefined | RangeInfoBuilder::Position(_) => vec![], + RangeInfoBuilder::Ranges(ranges) => ranges.clone(), + RangeInfoBuilder::Function(index) => { + let range = addr_tr.func_source_range(*index); + vec![(range.0, range.1)] + } + } + } + + pub(crate) fn build_ranges( + &self, + addr_tr: &AddressTransform, + out_range_lists: &mut write::RangeListTable, + ) -> write::RangeListId { + if let RangeInfoBuilder::Ranges(ranges) = self { + let mut range_list = Vec::new(); + for (begin, end) in ranges { + assert_lt!(begin, end); + for tr in addr_tr.translate_ranges(*begin, *end) { + if tr.1 == 0 { + // Ignore empty range + continue; + } + range_list.push(write::Range::StartLength { + begin: tr.0, + length: tr.1, + }); + } + } + out_range_lists.add(write::RangeList(range_list)) + } else { + unreachable!(); + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +
+//! Helper utils for tracking and patching intra unit or section references. + +use gimli::write; +use gimli::{CompilationUnitHeader, DebugInfoOffset, Reader, UnitOffset}; +use std::collections::HashMap; + +/// Stores compiled unit references: UnitEntryId+DwAt denotes a patch location +/// and UnitOffset is a location in original DWARF. +pub struct PendingUnitRefs { + refs: Vec<(write::UnitEntryId, gimli::DwAt, UnitOffset)>, +} + +impl PendingUnitRefs { + pub fn new() -> Self { + Self { refs: Vec::new() } + } + pub fn insert(&mut self, entry_id: write::UnitEntryId, attr: gimli::DwAt, offset: UnitOffset) { + self.refs.push((entry_id, attr, offset)); + } +} + +/// Stores .debug_info references: UnitEntryId+DwAt denotes a patch location +/// and DebugInfoOffset is a location in original DWARF. +pub struct PendingDebugInfoRefs { + refs: Vec<(write::UnitEntryId, gimli::DwAt, DebugInfoOffset)>, +} + +impl PendingDebugInfoRefs { + pub fn new() -> Self { + Self { refs: Vec::new() } + } + pub fn insert( + &mut self, + entry_id: write::UnitEntryId, + attr: gimli::DwAt, + offset: DebugInfoOffset, + ) { + self.refs.push((entry_id, attr, offset)); + } +} + +/// Stores map between read and written references of DWARF entries of +/// a compiled unit. +pub struct UnitRefsMap { + map: HashMap<UnitOffset, write::UnitEntryId>, +} + +impl UnitRefsMap { + pub fn new() -> Self { + Self { + map: HashMap::new(), + } + } + pub fn insert(&mut self, offset: UnitOffset, entry_id: write::UnitEntryId) { + self.map.insert(offset, entry_id); + } + pub fn patch(&self, refs: PendingUnitRefs, comp_unit: &mut write::Unit) { + for (die_id, attr_name, offset) in refs.refs { + let die = comp_unit.get_mut(die_id); + if let Some(unit_id) = self.map.get(&offset) { + die.set(attr_name, write::AttributeValue::ThisUnitEntryRef(*unit_id)); + } + } + } +} + +/// Stores map between read and written references of DWARF entries of +/// the entire .debug_info. +pub struct DebugInfoRefsMap { + map: HashMap<DebugInfoOffset, (write::UnitId, write::UnitEntryId)>, +} + +impl DebugInfoRefsMap { + pub fn new() -> Self { + Self { + map: HashMap::new(), + } + } + pub fn insert<R>( + &mut self, + unit: &CompilationUnitHeader<R>, + unit_id: write::UnitId, + unit_map: UnitRefsMap, + ) where + R: Reader<Offset = usize>, + { + self.map + .extend(unit_map.map.into_iter().map(|(off, entry_id)| { + let off = off.to_debug_info_offset(unit); + (off, (unit_id, entry_id)) + })); + } + pub fn patch( + &self, + refs: impl Iterator<Item = (write::UnitId, PendingDebugInfoRefs)>, + units: &mut write::UnitTable, + ) { + for (id, refs) in refs { + let unit = units.get_mut(id); + for (die_id, attr_name, offset) in refs.refs { + let die = unit.get_mut(die_id); + if let Some((id, entry_id)) = self.map.get(&offset) { + die.set( + attr_name, + write::AttributeValue::AnyUnitEntryRef((*id, *entry_id)), + ); + } + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +
+use super::expression::{CompiledExpression, FunctionFrameInfo}; +use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info}; +use super::AddressTransform; +use crate::read_debuginfo::WasmFileInfo; +use anyhow::Error; +use gimli::write; +use gimli::{self, LineEncoding}; +use std::collections::{HashMap, HashSet}; +use std::path::PathBuf; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::wasm::get_vmctx_value_label; +use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges}; + +pub use crate::read_debuginfo::{DebugInfoData, FunctionMetadata, WasmType}; + +const PRODUCER_NAME: &str = "wasmtime"; + +fn generate_line_info( + addr_tr: &AddressTransform, + translated: &HashSet<u32>, + out_encoding: gimli::Encoding, + w: &WasmFileInfo, + comp_dir_id: write::StringId, + name_id: write::StringId, + name: &str, +) -> Result<write::LineProgram, Error> { + let out_comp_dir = write::LineString::StringRef(comp_dir_id); + let out_comp_name = write::LineString::StringRef(name_id); + + let line_encoding = LineEncoding::default(); + + let mut out_program = write::LineProgram::new( + out_encoding, + line_encoding, + out_comp_dir, + out_comp_name, + None, + ); + + let file_index = out_program.add_file( + write::LineString::String(name.as_bytes().to_vec()), + out_program.default_directory(), + None, + ); + + for (i, map) in addr_tr.map() { + let symbol = i.index(); + if translated.contains(&(symbol as u32)) { + continue; + } + + let base_addr = map.offset; + out_program.begin_sequence(Some(write::Address::Symbol { symbol, addend: 0 })); + for addr_map in map.addresses.iter() { + let address_offset = (addr_map.generated - base_addr) as u64; + out_program.row().address_offset = address_offset; + out_program.row().op_index = 0; + out_program.row().file = file_index; + let wasm_offset = w.code_section_offset + addr_map.wasm as u64; + out_program.row().line = wasm_offset; + out_program.row().column = 0; + out_program.row().discriminator = 1; + out_program.row().is_statement = true; + out_program.row().basic_block = false; + out_program.row().prologue_end = false; + out_program.row().epilogue_begin = false; + out_program.row().isa = 0; + out_program.generate_row(); + } + let end_addr = (map.offset + map.len - 1) as u64; + out_program.end_sequence(end_addr); + } + + Ok(out_program) +} + +fn autogenerate_dwarf_wasm_path(di: &DebugInfoData) -> PathBuf { + let module_name = di + .name_section + .as_ref() + .and_then(|ns| ns.module_name.to_owned()) + .unwrap_or_else(|| unsafe { + static mut GEN_ID: u32 = 0; + GEN_ID += 1; + format!("<gen-{}>", GEN_ID) + }); + let path = format!("/<wasm-module>/{}.wasm", module_name); + PathBuf::from(path) +} + +struct WasmTypesDieRefs { + vmctx: write::UnitEntryId, + i32: write::UnitEntryId, + i64: write::UnitEntryId, + f32: write::UnitEntryId, + f64: write::UnitEntryId, +} + +fn add_wasm_types( + unit: &mut write::Unit, + root_id: write::UnitEntryId, + out_strings: &mut write::StringTable, + vmctx_info: &ModuleVmctxInfo, +) -> WasmTypesDieRefs { + let (_wp_die_id, vmctx_die_id) = add_internal_types(unit, root_id, out_strings, vmctx_info); + + macro_rules! def_type { + ($id:literal, $size:literal, $enc:path) => {{ + let die_id = unit.add(root_id, gimli::DW_TAG_base_type); + let die = unit.get_mut(die_id); + die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add($id)), + ); + die.set(gimli::DW_AT_byte_size, write::AttributeValue::Data1($size)); + die.set(gimli::DW_AT_encoding, write::AttributeValue::Encoding($enc)); + die_id + }}; + } + + let i32_die_id = def_type!("i32", 4, gimli::DW_ATE_signed); + let i64_die_id = def_type!("i64", 8, gimli::DW_ATE_signed); + let f32_die_id = def_type!("f32", 4, gimli::DW_ATE_float); + let f64_die_id = def_type!("f64", 8, gimli::DW_ATE_float); + + WasmTypesDieRefs { + vmctx: vmctx_die_id, + i32: i32_die_id, + i64: i64_die_id, + f32: f32_die_id, + f64: f64_die_id, + } +} + +fn resolve_var_type( + index: usize, + wasm_types: &WasmTypesDieRefs, + func_meta: &FunctionMetadata, +) -> Option<(write::UnitEntryId, bool)> { + let (ty, is_param) = if index < func_meta.params.len() { + (func_meta.params[index], true) + } else { + let mut i = (index - func_meta.params.len()) as u32; + let mut j = 0; + while j < func_meta.locals.len() && i >= func_meta.locals[j].0 { + i -= func_meta.locals[j].0; + j += 1; + } + if j >= func_meta.locals.len() { + // Ignore the var index out of bound. + return None; + } + (func_meta.locals[j].1, false) + }; + let type_die_id = match ty { + WasmType::I32 => wasm_types.i32, + WasmType::I64 => wasm_types.i64, + WasmType::F32 => wasm_types.f32, + WasmType::F64 => wasm_types.f64, + _ => { + // Ignore unsupported types. + return None; + } + }; + Some((type_die_id, is_param)) +} + +fn generate_vars( + unit: &mut write::Unit, + die_id: write::UnitEntryId, + addr_tr: &AddressTransform, + frame_info: &FunctionFrameInfo, + scope_ranges: &[(u64, u64)], + wasm_types: &WasmTypesDieRefs, + func_meta: &FunctionMetadata, + locals_names: Option<&HashMap<u32, String>>, + out_strings: &mut write::StringTable, +) { + let vmctx_label = get_vmctx_value_label(); + + for label in frame_info.value_ranges.keys() { + if label.index() == vmctx_label.index() { + append_vmctx_info( + unit, + die_id, + wasm_types.vmctx, + addr_tr, + Some(frame_info), + scope_ranges, + out_strings, + ) + .expect("append_vmctx_info success"); + } else { + let var_index = label.index(); + let (type_die_id, is_param) = + if let Some(result) = resolve_var_type(var_index, wasm_types, func_meta) { + result + } else { + // Skipping if type of local cannot be detected. + continue; + }; + + let loc_list_id = { + let endian = gimli::RunTimeEndian::Little; + + let expr = CompiledExpression::from_label(*label); + let mut locs = Vec::new(); + for (begin, length, data) in + expr.build_with_locals(scope_ranges, addr_tr, Some(frame_info), endian) + { + locs.push(write::Location::StartLength { + begin, + length, + data, + }); + } + unit.locations.add(write::LocationList(locs)) + }; + + let var_id = unit.add( + die_id, + if is_param { + gimli::DW_TAG_formal_parameter + } else { + gimli::DW_TAG_variable + }, + ); + let var = unit.get_mut(var_id); + + let name_id = match locals_names.and_then(|m| m.get(&(var_index as u32))) { + Some(n) => out_strings.add(n.to_owned()), + None => out_strings.add(format!("var{}", var_index)), + }; + + var.set(gimli::DW_AT_name, write::AttributeValue::StringRef(name_id)); + var.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(type_die_id), + ); + var.set( + gimli::DW_AT_location, + write::AttributeValue::LocationListRef(loc_list_id), + ); + } + } +} + +pub fn generate_simulated_dwarf( + addr_tr: &AddressTransform, + di: &DebugInfoData, + vmctx_info: &ModuleVmctxInfo, + ranges: &ValueLabelsRanges, + translated: &HashSet<u32>, + out_encoding: gimli::Encoding, + out_units: &mut write::UnitTable, + out_strings: &mut write::StringTable, +) -> Result<(), Error> { + let path = di + .wasm_file + .path + .to_owned() + .unwrap_or_else(|| autogenerate_dwarf_wasm_path(di)); + + let (func_names, locals_names) = if let Some(ref name_section) = di.name_section { + ( + Some(&name_section.func_names), + Some(&name_section.locals_names), + ) + } else { + (None, None) + }; + + let (unit, root_id, name_id) = { + let comp_dir_id = out_strings.add(path.parent().expect("path dir").to_str().unwrap()); + let name = path.file_name().expect("path name").to_str().unwrap(); + let name_id = out_strings.add(name); + + let out_program = generate_line_info( + addr_tr, + translated, + out_encoding, + &di.wasm_file, + comp_dir_id, + name_id, + name, + )?; + + let unit_id = out_units.add(write::Unit::new(out_encoding, out_program)); + let unit = out_units.get_mut(unit_id); + + let root_id = unit.root(); + let root = unit.get_mut(root_id); + + let id = out_strings.add(PRODUCER_NAME); + root.set(gimli::DW_AT_producer, write::AttributeValue::StringRef(id)); + root.set(gimli::DW_AT_name, write::AttributeValue::StringRef(name_id)); + root.set( + gimli::DW_AT_stmt_list, + write::AttributeValue::LineProgramRef, + ); + root.set( + gimli::DW_AT_comp_dir, + write::AttributeValue::StringRef(comp_dir_id), + ); + (unit, root_id, name_id) + }; + + let wasm_types = add_wasm_types(unit, root_id, out_strings, vmctx_info); + + for (i, map) in addr_tr.map().iter() { + let index = i.index(); + if translated.contains(&(index as u32)) { + continue; + } + + let start = map.offset as u64; + let end = start + map.len as u64; + let die_id = unit.add(root_id, gimli::DW_TAG_subprogram); + let die = unit.get_mut(die_id); + die.set( + gimli::DW_AT_low_pc, + write::AttributeValue::Address(write::Address::Symbol { + symbol: index, + addend: start as i64, + }), + ); + die.set( + gimli::DW_AT_high_pc, + write::AttributeValue::Udata((end - start) as u64), + ); + + let id = match func_names.and_then(|m| m.get(&(index as u32))) { + Some(n) => out_strings.add(n.to_owned()), + None => out_strings.add(format!("wasm-function[{}]", index)), + }; + + die.set(gimli::DW_AT_name, write::AttributeValue::StringRef(id)); + + die.set( + gimli::DW_AT_decl_file, + write::AttributeValue::StringRef(name_id), + ); + + let f = addr_tr.map().get(i).unwrap(); + let f_start = f.addresses[0].wasm; + let wasm_offset = di.wasm_file.code_section_offset + f_start as u64; + die.set( + gimli::DW_AT_decl_file, + write::AttributeValue::Udata(wasm_offset), + ); + + if let Some(frame_info) = get_function_frame_info(vmctx_info, i, ranges) { + let source_range = addr_tr.func_source_range(i); + generate_vars( + unit, + die_id, + addr_tr, + &frame_info, + &[(source_range.0, source_range.1)], + &wasm_types, + &di.wasm_file.funcs[index], + locals_names.and_then(|m| m.get(&(index as u32))), + out_strings, + ); + } + } + + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +
+use super::address_transform::AddressTransform; +use super::attr::{clone_die_attributes, FileAttributeContext}; +use super::expression::compile_expression; +use super::line_program::clone_line_program; +use super::range_info_builder::RangeInfoBuilder; +use super::refs::{PendingDebugInfoRefs, PendingUnitRefs, UnitRefsMap}; +use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info}; +use super::{DebugInputContext, Reader, TransformError}; +use anyhow::Error; +use gimli::write; +use gimli::{AttributeValue, DebuggingInformationEntry, Unit}; +use std::collections::HashSet; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges}; + +struct InheritedAttr<T> { + stack: Vec<(usize, T)>, +} + +impl<T> InheritedAttr<T> { + fn new() -> Self { + InheritedAttr { stack: Vec::new() } + } + + fn update(&mut self, depth: usize) { + while !self.stack.is_empty() && self.stack.last().unwrap().0 >= depth { + self.stack.pop(); + } + } + + fn push(&mut self, depth: usize, value: T) { + self.stack.push((depth, value)); + } + + fn top(&self) -> Option<&T> { + self.stack.last().map(|entry| &entry.1) + } + + fn is_empty(&self) -> bool { + self.stack.is_empty() + } +} + +fn get_base_type_name<R>( + type_entry: &DebuggingInformationEntry<R>, + unit: &Unit<R, R::Offset>, + context: &DebugInputContext<R>, +) -> Result<String, Error> +where + R: Reader, +{ + // FIXME remove recursion. + if let Some(AttributeValue::UnitRef(ref offset)) = type_entry.attr_value(gimli::DW_AT_type)? { + let mut entries = unit.entries_at_offset(*offset)?; + entries.next_entry()?; + if let Some(die) = entries.current() { + if let Some(AttributeValue::DebugStrRef(str_offset)) = + die.attr_value(gimli::DW_AT_name)? + { + return Ok(String::from( + context.debug_str.get_str(str_offset)?.to_string()?, + )); + } + match die.tag() { + gimli::DW_TAG_const_type => { + return Ok(format!("const {}", get_base_type_name(die, unit, context)?)); + } + gimli::DW_TAG_pointer_type => { + return Ok(format!("{}*", get_base_type_name(die, unit, context)?)); + } + gimli::DW_TAG_reference_type => { + return Ok(format!("{}&", get_base_type_name(die, unit, context)?)); + } + gimli::DW_TAG_array_type => { + return Ok(format!("{}[]", get_base_type_name(die, unit, context)?)); + } + _ => (), + } + } + } + Ok(String::from("??")) +} + +fn replace_pointer_type<R>( + parent_id: write::UnitEntryId, + comp_unit: &mut write::Unit, + wp_die_id: write::UnitEntryId, + entry: &DebuggingInformationEntry<R>, + unit: &Unit<R, R::Offset>, + context: &DebugInputContext<R>, + out_strings: &mut write::StringTable, + pending_die_refs: &mut PendingUnitRefs, +) -> Result<write::UnitEntryId, Error> +where + R: Reader, +{ + let die_id = comp_unit.add(parent_id, gimli::DW_TAG_structure_type); + let die = comp_unit.get_mut(die_id); + + let name = format!( + "WebAssemblyPtrWrapper<{}>", + get_base_type_name(entry, unit, context)? + ); + die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add(name.as_str())), + ); + die.set(gimli::DW_AT_byte_size, write::AttributeValue::Data1(4)); + + let p_die_id = comp_unit.add(die_id, gimli::DW_TAG_template_type_parameter); + let p_die = comp_unit.get_mut(p_die_id); + p_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("T")), + ); + p_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(wp_die_id), + ); + if let Some(AttributeValue::UnitRef(ref offset)) = entry.attr_value(gimli::DW_AT_type)? { + pending_die_refs.insert(p_die_id, gimli::DW_AT_type, *offset); + } + + let m_die_id = comp_unit.add(die_id, gimli::DW_TAG_member); + let m_die = comp_unit.get_mut(m_die_id); + m_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("__ptr")), + ); + m_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(wp_die_id), + ); + m_die.set( + gimli::DW_AT_data_member_location, + write::AttributeValue::Data1(0), + ); + Ok(die_id) +} + +pub(crate) fn clone_unit<'a, R>( + unit: Unit<R, R::Offset>, + context: &DebugInputContext<R>, + addr_tr: &'a AddressTransform, + value_ranges: &'a ValueLabelsRanges, + out_encoding: gimli::Encoding, + module_info: &ModuleVmctxInfo, + out_units: &mut write::UnitTable, + out_strings: &mut write::StringTable, + translated: &mut HashSet<u32>, +) -> Result<Option<(write::UnitId, UnitRefsMap, PendingDebugInfoRefs)>, Error> +where + R: Reader, +{ + let mut die_ref_map = UnitRefsMap::new(); + let mut pending_die_refs = PendingUnitRefs::new(); + let mut pending_di_refs = PendingDebugInfoRefs::new(); + let mut stack = Vec::new(); + + // Iterate over all of this compilation unit's entries. + let mut entries = unit.entries(); + let (mut comp_unit, unit_id, file_map, cu_low_pc, wp_die_id, vmctx_die_id) = + if let Some((depth_delta, entry)) = entries.next_dfs()? { + assert_eq!(depth_delta, 0); + let (out_line_program, debug_line_offset, file_map) = clone_line_program( + &unit, + entry, + addr_tr, + out_encoding, + context.debug_str, + context.debug_line, + out_strings, + )?; + + if entry.tag() == gimli::DW_TAG_compile_unit { + let unit_id = out_units.add(write::Unit::new(out_encoding, out_line_program)); + let comp_unit = out_units.get_mut(unit_id); + + let root_id = comp_unit.root(); + die_ref_map.insert(entry.offset(), root_id); + + let cu_low_pc = if let Some(AttributeValue::Addr(addr)) = + entry.attr_value(gimli::DW_AT_low_pc)? + { + addr + } else { + // FIXME? return Err(TransformError("No low_pc for unit header").into()); + 0 + }; + + clone_die_attributes( + entry, + context, + addr_tr, + None, + unit.encoding(), + comp_unit, + root_id, + None, + None, + cu_low_pc, + out_strings, + &mut pending_die_refs, + &mut pending_di_refs, + FileAttributeContext::Root(Some(debug_line_offset)), + )?; + + let (wp_die_id, vmctx_die_id) = + add_internal_types(comp_unit, root_id, out_strings, module_info); + + stack.push(root_id); + ( + comp_unit, + unit_id, + file_map, + cu_low_pc, + wp_die_id, + vmctx_die_id, + ) + } else { + return Err(TransformError("Unexpected unit header").into()); + } + } else { + return Ok(None); // empty + }; + let mut skip_at_depth = None; + let mut current_frame_base = InheritedAttr::new(); + let mut current_value_range = InheritedAttr::new(); + let mut current_scope_ranges = InheritedAttr::new(); + while let Some((depth_delta, entry)) = entries.next_dfs()? { + let depth_delta = if let Some((depth, cached)) = skip_at_depth { + let new_depth = depth + depth_delta; + if new_depth > 0 { + skip_at_depth = Some((new_depth, cached)); + continue; + } + skip_at_depth = None; + new_depth + cached + } else { + depth_delta + }; + + if !context + .reachable + .contains(&entry.offset().to_unit_section_offset(&unit)) + { + // entry is not reachable: discarding all its info. + skip_at_depth = Some((0, depth_delta)); + continue; + } + + let new_stack_len = stack.len().wrapping_add(depth_delta as usize); + current_frame_base.update(new_stack_len); + current_scope_ranges.update(new_stack_len); + current_value_range.update(new_stack_len); + let range_builder = if entry.tag() == gimli::DW_TAG_subprogram { + let range_builder = RangeInfoBuilder::from_subprogram_die( + entry, + context, + unit.encoding(), + addr_tr, + cu_low_pc, + )?; + if let RangeInfoBuilder::Function(func_index) = range_builder { + if let Some(frame_info) = + get_function_frame_info(module_info, func_index, value_ranges) + { + current_value_range.push(new_stack_len, frame_info); + } + translated.insert(func_index.index() as u32); + current_scope_ranges.push(new_stack_len, range_builder.get_ranges(addr_tr)); + Some(range_builder) + } else { + // FIXME current_scope_ranges.push() + None + } + } else { + let high_pc = entry.attr_value(gimli::DW_AT_high_pc)?; + let ranges = entry.attr_value(gimli::DW_AT_ranges)?; + if high_pc.is_some() || ranges.is_some() { + let range_builder = + RangeInfoBuilder::from(entry, context, unit.encoding(), cu_low_pc)?; + current_scope_ranges.push(new_stack_len, range_builder.get_ranges(addr_tr)); + Some(range_builder) + } else { + None + } + }; + + if depth_delta <= 0 { + for _ in depth_delta..1 { + stack.pop(); + } + } else { + assert_eq!(depth_delta, 1); + } + + if let Some(AttributeValue::Exprloc(expr)) = entry.attr_value(gimli::DW_AT_frame_base)? { + if let Some(expr) = compile_expression(&expr, unit.encoding(), None)? { + current_frame_base.push(new_stack_len, expr); + } + } + + let parent = stack.last().unwrap(); + + if entry.tag() == gimli::DW_TAG_pointer_type { + // Wrap pointer types. + // TODO reference types? + let die_id = replace_pointer_type( + *parent, + comp_unit, + wp_die_id, + entry, + &unit, + context, + out_strings, + &mut pending_die_refs, + )?; + stack.push(die_id); + assert_eq!(stack.len(), new_stack_len); + die_ref_map.insert(entry.offset(), die_id); + continue; + } + + let die_id = comp_unit.add(*parent, entry.tag()); + + stack.push(die_id); + assert_eq!(stack.len(), new_stack_len); + die_ref_map.insert(entry.offset(), die_id); + + clone_die_attributes( + entry, + context, + addr_tr, + current_value_range.top(), + unit.encoding(), + &mut comp_unit, + die_id, + range_builder, + current_scope_ranges.top(), + cu_low_pc, + out_strings, + &mut pending_die_refs, + &mut pending_di_refs, + FileAttributeContext::Children(&file_map, current_frame_base.top()), + )?; + + if entry.tag() == gimli::DW_TAG_subprogram && !current_scope_ranges.is_empty() { + append_vmctx_info( + comp_unit, + die_id, + vmctx_die_id, + addr_tr, + current_value_range.top(), + current_scope_ranges.top().expect("range"), + out_strings, + )?; + } + } + die_ref_map.patch(pending_die_refs, comp_unit); + Ok(Some((unit_id, die_ref_map, pending_di_refs))) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +
+use super::address_transform::AddressTransform; +use super::expression::{CompiledExpression, FunctionFrameInfo}; +use anyhow::Error; +use gimli::write; +use wasmtime_environ::wasm::DefinedFuncIndex; +use wasmtime_environ::{ModuleMemoryOffset, ModuleVmctxInfo, ValueLabelsRanges}; + +pub(crate) fn add_internal_types( + comp_unit: &mut write::Unit, + root_id: write::UnitEntryId, + out_strings: &mut write::StringTable, + module_info: &ModuleVmctxInfo, +) -> (write::UnitEntryId, write::UnitEntryId) { + let wp_die_id = comp_unit.add(root_id, gimli::DW_TAG_base_type); + let wp_die = comp_unit.get_mut(wp_die_id); + wp_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("WebAssemblyPtr")), + ); + wp_die.set(gimli::DW_AT_byte_size, write::AttributeValue::Data1(4)); + wp_die.set( + gimli::DW_AT_encoding, + write::AttributeValue::Encoding(gimli::DW_ATE_unsigned), + ); + + let memory_byte_die_id = comp_unit.add(root_id, gimli::DW_TAG_base_type); + let memory_byte_die = comp_unit.get_mut(memory_byte_die_id); + memory_byte_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("u8")), + ); + memory_byte_die.set( + gimli::DW_AT_encoding, + write::AttributeValue::Encoding(gimli::DW_ATE_unsigned), + ); + memory_byte_die.set(gimli::DW_AT_byte_size, write::AttributeValue::Data1(1)); + + let memory_bytes_die_id = comp_unit.add(root_id, gimli::DW_TAG_pointer_type); + let memory_bytes_die = comp_unit.get_mut(memory_bytes_die_id); + memory_bytes_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("u8*")), + ); + memory_bytes_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(memory_byte_die_id), + ); + + // Create artificial VMContext type and its reference for convinience viewing + // its fields (such as memory ref) in a debugger. + let vmctx_die_id = comp_unit.add(root_id, gimli::DW_TAG_structure_type); + let vmctx_die = comp_unit.get_mut(vmctx_die_id); + vmctx_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("WasmtimeVMContext")), + ); + + match module_info.memory_offset { + ModuleMemoryOffset::Defined(memory_offset) => { + // The context has defined memory: extend the WasmtimeVMContext size + // past the "memory" field. + const MEMORY_FIELD_SIZE_PLUS_PADDING: u32 = 8; + vmctx_die.set( + gimli::DW_AT_byte_size, + write::AttributeValue::Data4(memory_offset + MEMORY_FIELD_SIZE_PLUS_PADDING), + ); + + // Define the "memory" field which is a direct pointer to allocated Wasm memory. + let m_die_id = comp_unit.add(vmctx_die_id, gimli::DW_TAG_member); + let m_die = comp_unit.get_mut(m_die_id); + m_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("memory")), + ); + m_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(memory_bytes_die_id), + ); + m_die.set( + gimli::DW_AT_data_member_location, + write::AttributeValue::Udata(memory_offset as u64), + ); + } + ModuleMemoryOffset::Imported(_) => { + // TODO implement convinience pointer to and additional types for VMMemoryImport. + } + ModuleMemoryOffset::None => (), + } + + let vmctx_ptr_die_id = comp_unit.add(root_id, gimli::DW_TAG_pointer_type); + let vmctx_ptr_die = comp_unit.get_mut(vmctx_ptr_die_id); + vmctx_ptr_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("WasmtimeVMContext*")), + ); + vmctx_ptr_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(vmctx_die_id), + ); + + (wp_die_id, vmctx_ptr_die_id) +} + +pub(crate) fn append_vmctx_info( + comp_unit: &mut write::Unit, + parent_id: write::UnitEntryId, + vmctx_die_id: write::UnitEntryId, + addr_tr: &AddressTransform, + frame_info: Option<&FunctionFrameInfo>, + scope_ranges: &[(u64, u64)], + out_strings: &mut write::StringTable, +) -> Result<(), Error> { + let loc = { + let endian = gimli::RunTimeEndian::Little; + + let expr = CompiledExpression::vmctx(); + let mut locs = Vec::new(); + for (begin, length, data) in + expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian) + { + locs.push(write::Location::StartLength { + begin, + length, + data, + }); + } + let list_id = comp_unit.locations.add(write::LocationList(locs)); + write::AttributeValue::LocationListRef(list_id) + }; + + let var_die_id = comp_unit.add(parent_id, gimli::DW_TAG_variable); + let var_die = comp_unit.get_mut(var_die_id); + var_die.set( + gimli::DW_AT_name, + write::AttributeValue::StringRef(out_strings.add("__vmctx")), + ); + var_die.set( + gimli::DW_AT_type, + write::AttributeValue::ThisUnitEntryRef(vmctx_die_id), + ); + var_die.set(gimli::DW_AT_location, loc); + + Ok(()) +} + +pub(crate) fn get_function_frame_info<'a, 'b, 'c>( + module_info: &'b ModuleVmctxInfo, + func_index: DefinedFuncIndex, + value_ranges: &'c ValueLabelsRanges, +) -> Option<FunctionFrameInfo<'a>> +where + 'b: 'a, + 'c: 'a, +{ + if let Some(value_ranges) = value_ranges.get(func_index) { + let frame_info = FunctionFrameInfo { + value_ranges, + memory_offset: module_info.memory_offset.clone(), + stack_slots: &module_info.stack_slots[func_index], + }; + Some(frame_info) + } else { + None + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +
+use faerie::artifact::{Decl, SectionKind}; +use faerie::*; +use gimli::write::{Address, Dwarf, EndianVec, Result, Sections, Writer}; +use gimli::{RunTimeEndian, SectionId}; + +#[derive(Clone)] +struct DebugReloc { + offset: u32, + size: u8, + name: String, + addend: i64, +} + +pub enum ResolvedSymbol { + PhysicalAddress(u64), + Reloc { name: String, addend: i64 }, +} + +pub trait SymbolResolver { + fn resolve_symbol(&self, symbol: usize, addend: i64) -> ResolvedSymbol; +} + +pub fn emit_dwarf( + artifact: &mut Artifact, + mut dwarf: Dwarf, + symbol_resolver: &dyn SymbolResolver, +) -> anyhow::Result<()> { + let endian = RunTimeEndian::Little; + + let mut sections = Sections::new(WriterRelocate::new(endian, symbol_resolver)); + dwarf.write(&mut sections)?; + sections.for_each_mut(|id, s| -> anyhow::Result<()> { + artifact.declare_with( + id.name(), + Decl::section(SectionKind::Debug), + s.writer.take(), + ) + })?; + sections.for_each_mut(|id, s| -> anyhow::Result<()> { + for reloc in &s.relocs { + artifact.link_with( + faerie::Link { + from: id.name(), + to: &reloc.name, + at: u64::from(reloc.offset), + }, + faerie::Reloc::Debug { + size: reloc.size, + addend: reloc.addend as i32, + }, + )?; + } + Ok(()) + })?; + Ok(()) +} + +#[derive(Clone)] +pub struct WriterRelocate<'a> { + relocs: Vec<DebugReloc>, + writer: EndianVec<RunTimeEndian>, + symbol_resolver: &'a dyn SymbolResolver, +} + +impl<'a> WriterRelocate<'a> { + pub fn new(endian: RunTimeEndian, symbol_resolver: &'a dyn SymbolResolver) -> Self { + WriterRelocate { + relocs: Vec::new(), + writer: EndianVec::new(endian), + symbol_resolver, + } + } +} + +impl<'a> Writer for WriterRelocate<'a> { + type Endian = RunTimeEndian; + + fn endian(&self) -> Self::Endian { + self.writer.endian() + } + + fn len(&self) -> usize { + self.writer.len() + } + + fn write(&mut self, bytes: &[u8]) -> Result<()> { + self.writer.write(bytes) + } + + fn write_at(&mut self, offset: usize, bytes: &[u8]) -> Result<()> { + self.writer.write_at(offset, bytes) + } + + fn write_address(&mut self, address: Address, size: u8) -> Result<()> { + match address { + Address::Constant(val) => self.write_udata(val, size), + Address::Symbol { symbol, addend } => { + match self.symbol_resolver.resolve_symbol(symbol, addend as i64) { + ResolvedSymbol::PhysicalAddress(addr) => self.write_udata(addr, size), + ResolvedSymbol::Reloc { name, addend } => { + let offset = self.len() as u64; + self.relocs.push(DebugReloc { + offset: offset as u32, + size, + name, + addend, + }); + self.write_udata(addend as u64, size) + } + } + } + } + } + + fn write_offset(&mut self, val: usize, section: SectionId, size: u8) -> Result<()> { + let offset = self.len() as u32; + let name = section.name().to_string(); + self.relocs.push(DebugReloc { + offset, + size, + name, + addend: val as i64, + }); + self.write_udata(val as u64, size) + } + + fn write_offset_at( + &mut self, + offset: usize, + val: usize, + section: SectionId, + size: u8, + ) -> Result<()> { + let name = section.name().to_string(); + self.relocs.push(DebugReloc { + offset: offset as u32, + size, + name, + addend: val as i64, + }); + self.write_udata_at(offset, val as u64, size) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +
+//! Data structures to provide transformation of the source +// addresses of a WebAssembly module into the native code. + +use cranelift_codegen::ir; +use cranelift_entity::PrimaryMap; +use cranelift_wasm::DefinedFuncIndex; +use serde::{Deserialize, Serialize}; + +/// Single source location to generated address mapping. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct InstructionAddressMap { + /// Original source location. + pub srcloc: ir::SourceLoc, + + /// Generated instructions offset. + pub code_offset: usize, + + /// Generated instructions length. + pub code_len: usize, +} + +/// Function and its instructions addresses mappings. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct FunctionAddressMap { + /// Instructions maps. + /// The array is sorted by the InstructionAddressMap::code_offset field. + pub instructions: Vec<InstructionAddressMap>, + + /// Function start source location (normally declaration). + pub start_srcloc: ir::SourceLoc, + + /// Function end source location. + pub end_srcloc: ir::SourceLoc, + + /// Generated function body offset if applicable, otherwise 0. + pub body_offset: usize, + + /// Generated function body length. + pub body_len: usize, +} + +/// Module functions addresses mappings. +pub type ModuleAddressMap = PrimaryMap<DefinedFuncIndex, FunctionAddressMap>; + +/// Value ranges for functions. +pub type ValueLabelsRanges = PrimaryMap<DefinedFuncIndex, cranelift_codegen::ValueLabelsRanges>; + +/// Stack slots for functions. +pub type StackSlots = PrimaryMap<DefinedFuncIndex, ir::StackSlots>; + +/// Memory definition offset in the VMContext structure. +#[derive(Debug, Clone)] +pub enum ModuleMemoryOffset { + /// Not available. + None, + /// Offset to the defined memory. + Defined(u32), + /// Offset to the imported memory. + Imported(u32), +} + +/// Module `vmctx` related info. +#[derive(Debug, Clone)] +pub struct ModuleVmctxInfo { + /// The memory definition offset in the VMContext structure. + pub memory_offset: ModuleMemoryOffset, + + /// The functions stack slots. + pub stack_slots: StackSlots, +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +
+use crate::address_map::{ModuleAddressMap, ValueLabelsRanges}; +use crate::compilation::{Compilation, Relocations, Traps}; +use crate::module::Module; +use crate::module_environ::FunctionBodyData; +use cranelift_codegen::{ir, isa}; +use cranelift_entity::PrimaryMap; +use cranelift_wasm::DefinedFuncIndex; +use log::{debug, trace, warn}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use std::fs; +use std::hash::Hasher; +use std::io::Write; +use std::path::{Path, PathBuf}; + +#[macro_use] // for tests +mod config; +mod worker; + +pub use config::{create_new_config, CacheConfig}; +use worker::Worker; + +pub struct ModuleCacheEntry<'config>(Option<ModuleCacheEntryInner<'config>>); + +struct ModuleCacheEntryInner<'config> { + mod_cache_path: PathBuf, + cache_config: &'config CacheConfig, +} + +/// Cached compilation data of a Wasm module. +#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)] +pub struct ModuleCacheData { + compilation: Compilation, + relocations: Relocations, + address_transforms: ModuleAddressMap, + value_ranges: ValueLabelsRanges, + stack_slots: PrimaryMap<DefinedFuncIndex, ir::StackSlots>, + traps: Traps, +} + +/// A type alias over the module cache data as a tuple. +pub type ModuleCacheDataTupleType = ( + Compilation, + Relocations, + ModuleAddressMap, + ValueLabelsRanges, + PrimaryMap<DefinedFuncIndex, ir::StackSlots>, + Traps, +); + +struct Sha256Hasher(Sha256); + +impl<'config> ModuleCacheEntry<'config> { + pub fn new<'data>( + module: &Module, + function_body_inputs: &PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + isa: &dyn isa::TargetIsa, + compiler_name: &str, + generate_debug_info: bool, + cache_config: &'config CacheConfig, + ) -> Self { + if cache_config.enabled() { + Self(Some(ModuleCacheEntryInner::new( + module, + function_body_inputs, + isa, + compiler_name, + generate_debug_info, + cache_config, + ))) + } else { + Self(None) + } + } + + #[cfg(test)] + fn from_inner(inner: ModuleCacheEntryInner<'config>) -> Self { + Self(Some(inner)) + } + + pub fn get_data(&self) -> Option<ModuleCacheData> { + if let Some(inner) = &self.0 { + inner.get_data().map(|val| { + inner + .cache_config + .worker() + .on_cache_get_async(&inner.mod_cache_path); // call on success + val + }) + } else { + None + } + } + + pub fn update_data(&self, data: &ModuleCacheData) { + if let Some(inner) = &self.0 { + if inner.update_data(data).is_some() { + inner + .cache_config + .worker() + .on_cache_update_async(&inner.mod_cache_path); // call on success + } + } + } +} + +impl<'config> ModuleCacheEntryInner<'config> { + fn new<'data>( + module: &Module, + function_body_inputs: &PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + isa: &dyn isa::TargetIsa, + compiler_name: &str, + generate_debug_info: bool, + cache_config: &'config CacheConfig, + ) -> Self { + let hash = Sha256Hasher::digest(module, function_body_inputs); + let compiler_dir = if cfg!(debug_assertions) { + fn self_mtime() -> Option<String> { + let path = std::env::current_exe().ok()?; + let metadata = path.metadata().ok()?; + let mtime = metadata.modified().ok()?; + Some(match mtime.duration_since(std::time::UNIX_EPOCH) { + Ok(dur) => format!("{}", dur.as_millis()), + Err(err) => format!("m{}", err.duration().as_millis()), + }) + } + let self_mtime = self_mtime().unwrap_or("no-mtime".to_string()); + format!( + "{comp_name}-{comp_ver}-{comp_mtime}", + comp_name = compiler_name, + comp_ver = env!("GIT_REV"), + comp_mtime = self_mtime, + ) + } else { + format!( + "{comp_name}-{comp_ver}", + comp_name = compiler_name, + comp_ver = env!("GIT_REV"), + ) + }; + let mod_filename = format!( + "mod-{mod_hash}{mod_dbg}", + mod_hash = base64::encode_config(&hash, base64::URL_SAFE_NO_PAD), // standard encoding uses '/' which can't be used for filename + mod_dbg = if generate_debug_info { ".d" } else { "" }, + ); + let mod_cache_path = cache_config + .directory() + .join(isa.triple().to_string()) + .join(compiler_dir) + .join(mod_filename); + + Self { + mod_cache_path, + cache_config, + } + } + + fn get_data(&self) -> Option<ModuleCacheData> { + trace!("get_data() for path: {}", self.mod_cache_path.display()); + let compressed_cache_bytes = fs::read(&self.mod_cache_path).ok()?; + let cache_bytes = zstd::decode_all(&compressed_cache_bytes[..]) + .map_err(|err| warn!("Failed to decompress cached code: {}", err)) + .ok()?; + bincode::deserialize(&cache_bytes[..]) + .map_err(|err| warn!("Failed to deserialize cached code: {}", err)) + .ok() + } + + fn update_data(&self, data: &ModuleCacheData) -> Option<()> { + trace!("update_data() for path: {}", self.mod_cache_path.display()); + let serialized_data = bincode::serialize(&data) + .map_err(|err| warn!("Failed to serialize cached code: {}", err)) + .ok()?; + let compressed_data = zstd::encode_all( + &serialized_data[..], + self.cache_config.baseline_compression_level(), + ) + .map_err(|err| warn!("Failed to compress cached code: {}", err)) + .ok()?; + + // Optimize syscalls: first, try writing to disk. It should succeed in most cases. + // Otherwise, try creating the cache directory and retry writing to the file. + if fs_write_atomic(&self.mod_cache_path, "mod", &compressed_data) { + return Some(()); + } + + debug!( + "Attempting to create the cache directory, because \ + failed to write cached code to disk, path: {}", + self.mod_cache_path.display(), + ); + + let cache_dir = self.mod_cache_path.parent().unwrap(); + fs::create_dir_all(cache_dir) + .map_err(|err| { + warn!( + "Failed to create cache directory, path: {}, message: {}", + cache_dir.display(), + err + ) + }) + .ok()?; + + if fs_write_atomic(&self.mod_cache_path, "mod", &compressed_data) { + Some(()) + } else { + None + } + } +} + +impl ModuleCacheData { + pub fn from_tuple(data: ModuleCacheDataTupleType) -> Self { + Self { + compilation: data.0, + relocations: data.1, + address_transforms: data.2, + value_ranges: data.3, + stack_slots: data.4, + traps: data.5, + } + } + + pub fn into_tuple(self) -> ModuleCacheDataTupleType { + ( + self.compilation, + self.relocations, + self.address_transforms, + self.value_ranges, + self.stack_slots, + self.traps, + ) + } +} + +impl Sha256Hasher { + pub fn digest<'data>( + module: &Module, + function_body_inputs: &PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + ) -> [u8; 32] { + let mut hasher = Self(Sha256::new()); + module.hash_for_cache(function_body_inputs, &mut hasher); + hasher.0.result().into() + } +} + +impl Hasher for Sha256Hasher { + fn finish(&self) -> u64 { + panic!("Sha256Hasher doesn't support finish!"); + } + + fn write(&mut self, bytes: &[u8]) { + self.0.input(bytes); + } +} + +// Assumption: path inside cache directory. +// Then, we don't have to use sound OS-specific exclusive file access. +// Note: there's no need to remove temporary file here - cleanup task will do it later. +fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> bool { + let lock_path = path.with_extension(format!("wip-atomic-write-{}", reason)); + fs::OpenOptions::new() + .create_new(true) // atomic file creation (assumption: no one will open it without this flag) + .write(true) + .open(&lock_path) + .and_then(|mut file| file.write_all(contents)) + // file should go out of scope and be closed at this point + .and_then(|()| fs::rename(&lock_path, &path)) // atomic file rename + .map_err(|err| { + warn!( + "Failed to write file with rename, lock path: {}, target path: {}, err: {}", + lock_path.display(), + path.display(), + err + ) + }) + .is_ok() +} + +#[cfg(test)] +mod tests; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +
+//! Module for configuring the cache system. + +use super::Worker; +use anyhow::{anyhow, bail, Context, Result}; +use directories::ProjectDirs; +use log::{trace, warn}; +use serde::{ + de::{self, Deserializer}, + Deserialize, +}; +use std::fmt::Debug; +use std::fs; +use std::path::{Path, PathBuf}; +use std::time::Duration; + +// wrapped, so we have named section in config, +// also, for possible future compatibility +#[derive(Deserialize, Debug)] +#[serde(deny_unknown_fields)] +struct Config { + cache: CacheConfig, +} + +/// Global configuration for how the cache is managed +#[derive(Deserialize, Debug, Clone)] +#[serde(deny_unknown_fields)] +pub struct CacheConfig { + enabled: bool, + directory: Option<PathBuf>, + #[serde( + default, + rename = "worker-event-queue-size", + deserialize_with = "deserialize_si_prefix" + )] + worker_event_queue_size: Option<u64>, + #[serde(rename = "baseline-compression-level")] + baseline_compression_level: Option<i32>, + #[serde(rename = "optimized-compression-level")] + optimized_compression_level: Option<i32>, + #[serde( + default, + rename = "optimized-compression-usage-counter-threshold", + deserialize_with = "deserialize_si_prefix" + )] + optimized_compression_usage_counter_threshold: Option<u64>, + #[serde( + default, + rename = "cleanup-interval", + deserialize_with = "deserialize_duration" + )] + cleanup_interval: Option<Duration>, + #[serde( + default, + rename = "optimizing-compression-task-timeout", + deserialize_with = "deserialize_duration" + )] + optimizing_compression_task_timeout: Option<Duration>, + #[serde( + default, + rename = "allowed-clock-drift-for-files-from-future", + deserialize_with = "deserialize_duration" + )] + allowed_clock_drift_for_files_from_future: Option<Duration>, + #[serde( + default, + rename = "file-count-soft-limit", + deserialize_with = "deserialize_si_prefix" + )] + file_count_soft_limit: Option<u64>, + #[serde( + default, + rename = "files-total-size-soft-limit", + deserialize_with = "deserialize_disk_space" + )] + files_total_size_soft_limit: Option<u64>, + #[serde( + default, + rename = "file-count-limit-percent-if-deleting", + deserialize_with = "deserialize_percent" + )] + file_count_limit_percent_if_deleting: Option<u8>, + #[serde( + default, + rename = "files-total-size-limit-percent-if-deleting", + deserialize_with = "deserialize_percent" + )] + files_total_size_limit_percent_if_deleting: Option<u8>, + + #[serde(skip)] + worker: Option<Worker>, +} + +/// Creates a new configuration file at specified path, or default path if None is passed. +/// Fails if file already exists. +pub fn create_new_config<P: AsRef<Path> + Debug>(config_file: Option<P>) -> Result<PathBuf> { + trace!("Creating new config file, path: {:?}", config_file); + + let config_file = match config_file { + Some(path) => path.as_ref().to_path_buf(), + None => default_config_path()?, + }; + + if config_file.exists() { + bail!( + "Configuration file '{}' already exists.", + config_file.display() + ); + } + + let parent_dir = config_file + .parent() + .ok_or_else(|| anyhow!("Invalid cache config path: {}", config_file.display()))?; + + fs::create_dir_all(parent_dir).with_context(|| { + format!( + "Failed to create config directory, config path: {}", + config_file.display(), + ) + })?; + + let content = "\ +# Comment out certain settings to use default values. +# For more settings, please refer to the documentation: +# https://bytecodealliance.github.io/wasmtime/cli-cache.html + +[cache] +enabled = true +"; + + fs::write(&config_file, &content).with_context(|| { + format!( + "Failed to flush config to the disk, path: {}", + config_file.display(), + ) + })?; + + Ok(config_file.to_path_buf()) +} + +// permitted levels from: https://docs.rs/zstd/0.4.28+zstd.1.4.3/zstd/stream/write/struct.Encoder.html +const ZSTD_COMPRESSION_LEVELS: std::ops::RangeInclusive<i32> = 0..=21; + +// Default settings, you're welcome to tune them! +// TODO: what do we want to warn users about? + +// At the moment of writing, the modules couldn't depend on anothers, +// so we have at most one module per wasmtime instance +// if changed, update cli-cache.md +const DEFAULT_WORKER_EVENT_QUEUE_SIZE: u64 = 0x10; +const WORKER_EVENT_QUEUE_SIZE_WARNING_TRESHOLD: u64 = 3; +// should be quick and provide good enough compression +// if changed, update cli-cache.md +const DEFAULT_BASELINE_COMPRESSION_LEVEL: i32 = zstd::DEFAULT_COMPRESSION_LEVEL; +// should provide significantly better compression than baseline +// if changed, update cli-cache.md +const DEFAULT_OPTIMIZED_COMPRESSION_LEVEL: i32 = 20; +// shouldn't be to low to avoid recompressing too many files +// if changed, update cli-cache.md +const DEFAULT_OPTIMIZED_COMPRESSION_USAGE_COUNTER_THRESHOLD: u64 = 0x100; +// if changed, update cli-cache.md +const DEFAULT_CLEANUP_INTERVAL: Duration = Duration::from_secs(60 * 60); +// if changed, update cli-cache.md +const DEFAULT_OPTIMIZING_COMPRESSION_TASK_TIMEOUT: Duration = Duration::from_secs(30 * 60); +// the default assumes problems with timezone configuration on network share + some clock drift +// please notice 24 timezones = max 23h difference between some of them +// if changed, update cli-cache.md +const DEFAULT_ALLOWED_CLOCK_DRIFT_FOR_FILES_FROM_FUTURE: Duration = + Duration::from_secs(60 * 60 * 24); +// if changed, update cli-cache.md +const DEFAULT_FILE_COUNT_SOFT_LIMIT: u64 = 0x10_000; +// if changed, update cli-cache.md +const DEFAULT_FILES_TOTAL_SIZE_SOFT_LIMIT: u64 = 1024 * 1024 * 512; +// if changed, update cli-cache.md +const DEFAULT_FILE_COUNT_LIMIT_PERCENT_IF_DELETING: u8 = 70; +// if changed, update cli-cache.md +const DEFAULT_FILES_TOTAL_SIZE_LIMIT_PERCENT_IF_DELETING: u8 = 70; + +fn project_dirs() -> Option<ProjectDirs> { + ProjectDirs::from("", "BytecodeAlliance", "wasmtime") +} + +fn default_config_path() -> Result<PathBuf> { + match project_dirs() { + Some(dirs) => Ok(dirs.config_dir().join("config.toml")), + None => bail!("config file not specified and failed to get the default"), + } +} + +// Deserializers of our custom formats +// can be replaced with const generics later +macro_rules! generate_deserializer { + ($name:ident($numname:ident: $numty:ty, $unitname:ident: &str) -> $retty:ty {$body:expr}) => { + fn $name<'de, D>(deserializer: D) -> Result<$retty, D::Error> + where + D: Deserializer<'de>, + { + let text = Option::<String>::deserialize(deserializer)?; + let text = match text { + None => return Ok(None), + Some(text) => text, + }; + let text = text.trim(); + let split_point = text.find(|c: char| !c.is_numeric()); + let (num, unit) = split_point.map_or_else(|| (text, ""), |p| text.split_at(p)); + let deserialized = (|| { + let $numname = num.parse::<$numty>().ok()?; + let $unitname = unit.trim(); + $body + })(); + if deserialized.is_some() { + Ok(deserialized) + } else { + Err(de::Error::custom( + "Invalid value, please refer to the documentation", + )) + } + } + }; +} + +generate_deserializer!(deserialize_duration(num: u64, unit: &str) -> Option<Duration> { + match unit { + "s" => Some(Duration::from_secs(num)), + "m" => Some(Duration::from_secs(num * 60)), + "h" => Some(Duration::from_secs(num * 60 * 60)), + "d" => Some(Duration::from_secs(num * 60 * 60 * 24)), + _ => None, + } +}); + +generate_deserializer!(deserialize_si_prefix(num: u64, unit: &str) -> Option<u64> { + match unit { + "" => Some(num), + "K" => num.checked_mul(1_000), + "M" => num.checked_mul(1_000_000), + "G" => num.checked_mul(1_000_000_000), + "T" => num.checked_mul(1_000_000_000_000), + "P" => num.checked_mul(1_000_000_000_000_000), + _ => None, + } +}); + +generate_deserializer!(deserialize_disk_space(num: u64, unit: &str) -> Option<u64> { + match unit { + "" => Some(num), + "K" => num.checked_mul(1_000), + "Ki" => num.checked_mul(1u64 << 10), + "M" => num.checked_mul(1_000_000), + "Mi" => num.checked_mul(1u64 << 20), + "G" => num.checked_mul(1_000_000_000), + "Gi" => num.checked_mul(1u64 << 30), + "T" => num.checked_mul(1_000_000_000_000), + "Ti" => num.checked_mul(1u64 << 40), + "P" => num.checked_mul(1_000_000_000_000_000), + "Pi" => num.checked_mul(1u64 << 50), + _ => None, + } +}); + +generate_deserializer!(deserialize_percent(num: u8, unit: &str) -> Option<u8> { + match unit { + "%" => Some(num), + _ => None, + } +}); + +static CACHE_IMPROPER_CONFIG_ERROR_MSG: &str = + "Cache system should be enabled and all settings must be validated or defaulted"; + +macro_rules! generate_setting_getter { + ($setting:ident: $setting_type:ty) => { + /// Returns `$setting`. + /// + /// Panics if the cache is disabled. + pub fn $setting(&self) -> $setting_type { + self + .$setting + .expect(CACHE_IMPROPER_CONFIG_ERROR_MSG) + } + }; +} + +impl CacheConfig { + generate_setting_getter!(worker_event_queue_size: u64); + generate_setting_getter!(baseline_compression_level: i32); + generate_setting_getter!(optimized_compression_level: i32); + generate_setting_getter!(optimized_compression_usage_counter_threshold: u64); + generate_setting_getter!(cleanup_interval: Duration); + generate_setting_getter!(optimizing_compression_task_timeout: Duration); + generate_setting_getter!(allowed_clock_drift_for_files_from_future: Duration); + generate_setting_getter!(file_count_soft_limit: u64); + generate_setting_getter!(files_total_size_soft_limit: u64); + generate_setting_getter!(file_count_limit_percent_if_deleting: u8); + generate_setting_getter!(files_total_size_limit_percent_if_deleting: u8); + + /// Returns true if and only if the cache is enabled. + pub fn enabled(&self) -> bool { + self.enabled + } + + /// Returns path to the cache directory. + /// + /// Panics if the cache is disabled. + pub fn directory(&self) -> &PathBuf { + self.directory + .as_ref() + .expect(CACHE_IMPROPER_CONFIG_ERROR_MSG) + } + + /// Creates a new set of configuration which represents a disabled cache + pub fn new_cache_disabled() -> Self { + Self { + enabled: false, + directory: None, + worker_event_queue_size: None, + baseline_compression_level: None, + optimized_compression_level: None, + optimized_compression_usage_counter_threshold: None, + cleanup_interval: None, + optimizing_compression_task_timeout: None, + allowed_clock_drift_for_files_from_future: None, + file_count_soft_limit: None, + files_total_size_soft_limit: None, + file_count_limit_percent_if_deleting: None, + files_total_size_limit_percent_if_deleting: None, + worker: None, + } + } + + fn new_cache_enabled_template() -> Self { + let mut conf = Self::new_cache_disabled(); + conf.enabled = true; + conf + } + + /// Parses cache configuration from the file specified + pub fn from_file(config_file: Option<&Path>) -> Result<Self> { + let mut config = Self::load_and_parse_file(config_file)?; + + // validate values and fill in defaults + config.validate_directory_or_default()?; + config.validate_worker_event_queue_size_or_default(); + config.validate_baseline_compression_level_or_default()?; + config.validate_optimized_compression_level_or_default()?; + config.validate_optimized_compression_usage_counter_threshold_or_default(); + config.validate_cleanup_interval_or_default(); + config.validate_optimizing_compression_task_timeout_or_default(); + config.validate_allowed_clock_drift_for_files_from_future_or_default(); + config.validate_file_count_soft_limit_or_default(); + config.validate_files_total_size_soft_limit_or_default(); + config.validate_file_count_limit_percent_if_deleting_or_default()?; + config.validate_files_total_size_limit_percent_if_deleting_or_default()?; + config.spawn_worker(); + + Ok(config) + } + + fn spawn_worker(&mut self) { + if self.enabled { + self.worker = Some(Worker::start_new(self, None)); + } + } + + pub(super) fn worker(&self) -> &Worker { + assert!(self.enabled); + self.worker.as_ref().unwrap() + } + + fn load_and_parse_file(config_file: Option<&Path>) -> Result<Self> { + // get config file path + let (config_file, user_custom_file) = match config_file { + Some(path) => (path.to_path_buf(), true), + None => (default_config_path()?, false), + }; + + // read config, or use default one + let entity_exists = config_file.exists(); + match (entity_exists, user_custom_file) { + (false, false) => Ok(Self::new_cache_enabled_template()), + _ => { + let bytes = fs::read(&config_file).context(format!( + "failed to read config file: {}", + config_file.display() + ))?; + let config = toml::from_slice::<Config>(&bytes[..]).context(format!( + "failed to parse config file: {}", + config_file.display() + ))?; + Ok(config.cache) + } + } + } + + fn validate_directory_or_default(&mut self) -> Result<()> { + if self.directory.is_none() { + match project_dirs() { + Some(proj_dirs) => self.directory = Some(proj_dirs.cache_dir().to_path_buf()), + None => { + bail!("Cache directory not specified and failed to get the default"); + } + } + } + + // On Windows, if we want long paths, we need '\\?\' prefix, but it doesn't work + // with relative paths. One way to get absolute path (the only one?) is to use + // fs::canonicalize, but it requires that given path exists. The extra advantage + // of this method is fact that the method prepends '\\?\' on Windows. + let cache_dir = self.directory.as_ref().unwrap(); + + if !cache_dir.is_absolute() { + bail!( + "Cache directory path has to be absolute, path: {}", + cache_dir.display(), + ); + } + + fs::create_dir_all(cache_dir).context(format!( + "failed to create cache directory: {}", + cache_dir.display() + ))?; + let canonical = fs::canonicalize(cache_dir).context(format!( + "failed to canonicalize cache directory: {}", + cache_dir.display() + ))?; + self.directory = Some(canonical); + Ok(()) + } + + fn validate_worker_event_queue_size_or_default(&mut self) { + if self.worker_event_queue_size.is_none() { + self.worker_event_queue_size = Some(DEFAULT_WORKER_EVENT_QUEUE_SIZE); + } + + if self.worker_event_queue_size.unwrap() < WORKER_EVENT_QUEUE_SIZE_WARNING_TRESHOLD { + warn!("Detected small worker event queue size. Some messages might be lost."); + } + } + + fn validate_baseline_compression_level_or_default(&mut self) -> Result<()> { + if self.baseline_compression_level.is_none() { + self.baseline_compression_level = Some(DEFAULT_BASELINE_COMPRESSION_LEVEL); + } + + if !ZSTD_COMPRESSION_LEVELS.contains(&self.baseline_compression_level.unwrap()) { + bail!( + "Invalid baseline compression level: {} not in {:#?}", + self.baseline_compression_level.unwrap(), + ZSTD_COMPRESSION_LEVELS + ); + } + Ok(()) + } + + // assumption: baseline compression level has been verified + fn validate_optimized_compression_level_or_default(&mut self) -> Result<()> { + if self.optimized_compression_level.is_none() { + self.optimized_compression_level = Some(DEFAULT_OPTIMIZED_COMPRESSION_LEVEL); + } + + let opt_lvl = self.optimized_compression_level.unwrap(); + let base_lvl = self.baseline_compression_level.unwrap(); + + if !ZSTD_COMPRESSION_LEVELS.contains(&opt_lvl) { + bail!( + "Invalid optimized compression level: {} not in {:#?}", + opt_lvl, + ZSTD_COMPRESSION_LEVELS + ); + } + + if opt_lvl < base_lvl { + bail!( + "Invalid optimized compression level is lower than baseline: {} < {}", + opt_lvl, + base_lvl + ); + } + Ok(()) + } + + fn validate_optimized_compression_usage_counter_threshold_or_default(&mut self) { + if self.optimized_compression_usage_counter_threshold.is_none() { + self.optimized_compression_usage_counter_threshold = + Some(DEFAULT_OPTIMIZED_COMPRESSION_USAGE_COUNTER_THRESHOLD); + } + } + + fn validate_cleanup_interval_or_default(&mut self) { + if self.cleanup_interval.is_none() { + self.cleanup_interval = Some(DEFAULT_CLEANUP_INTERVAL); + } + } + + fn validate_optimizing_compression_task_timeout_or_default(&mut self) { + if self.optimizing_compression_task_timeout.is_none() { + self.optimizing_compression_task_timeout = + Some(DEFAULT_OPTIMIZING_COMPRESSION_TASK_TIMEOUT); + } + } + + fn validate_allowed_clock_drift_for_files_from_future_or_default(&mut self) { + if self.allowed_clock_drift_for_files_from_future.is_none() { + self.allowed_clock_drift_for_files_from_future = + Some(DEFAULT_ALLOWED_CLOCK_DRIFT_FOR_FILES_FROM_FUTURE); + } + } + + fn validate_file_count_soft_limit_or_default(&mut self) { + if self.file_count_soft_limit.is_none() { + self.file_count_soft_limit = Some(DEFAULT_FILE_COUNT_SOFT_LIMIT); + } + } + + fn validate_files_total_size_soft_limit_or_default(&mut self) { + if self.files_total_size_soft_limit.is_none() { + self.files_total_size_soft_limit = Some(DEFAULT_FILES_TOTAL_SIZE_SOFT_LIMIT); + } + } + + fn validate_file_count_limit_percent_if_deleting_or_default(&mut self) -> Result<()> { + if self.file_count_limit_percent_if_deleting.is_none() { + self.file_count_limit_percent_if_deleting = + Some(DEFAULT_FILE_COUNT_LIMIT_PERCENT_IF_DELETING); + } + + let percent = self.file_count_limit_percent_if_deleting.unwrap(); + if percent > 100 { + bail!( + "Invalid files count limit percent if deleting: {} not in range 0-100%", + percent + ); + } + Ok(()) + } + + fn validate_files_total_size_limit_percent_if_deleting_or_default(&mut self) -> Result<()> { + if self.files_total_size_limit_percent_if_deleting.is_none() { + self.files_total_size_limit_percent_if_deleting = + Some(DEFAULT_FILES_TOTAL_SIZE_LIMIT_PERCENT_IF_DELETING); + } + + let percent = self.files_total_size_limit_percent_if_deleting.unwrap(); + if percent > 100 { + bail!( + "Invalid files total size limit percent if deleting: {} not in range 0-100%", + percent + ); + } + Ok(()) + } +} + +#[cfg(test)] +#[macro_use] +pub mod tests; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +883 +884 +885 +886 +887 +888 +889 +890 +891 +892 +893 +894 +895 +896 +897 +898 +899 +900 +
+//! Background worker that watches over the cache. +//! +//! It cleans up old cache, updates statistics and optimizes the cache. +//! We allow losing some messages (it doesn't hurt) and some races, +//! but we guarantee eventual consistency and fault tolerancy. +//! Background tasks can be CPU intensive, but the worker thread has low priority. + +use super::{fs_write_atomic, CacheConfig}; +use log::{debug, info, trace, warn}; +use serde::{Deserialize, Serialize}; +use std::cmp; +use std::collections::HashMap; +use std::ffi::OsStr; +use std::fmt; +use std::fs; +use std::path::{Path, PathBuf}; +use std::sync::mpsc::{sync_channel, Receiver, SyncSender}; +#[cfg(test)] +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; +use std::time::Duration; +#[cfg(not(test))] +use std::time::SystemTime; +#[cfg(test)] +use tests::system_time_stub::SystemTimeStub as SystemTime; + +#[derive(Clone)] +pub(super) struct Worker { + sender: SyncSender<CacheEvent>, + #[cfg(test)] + stats: Arc<(Mutex<WorkerStats>, Condvar)>, +} + +struct WorkerThread { + receiver: Receiver<CacheEvent>, + cache_config: CacheConfig, + #[cfg(test)] + stats: Arc<(Mutex<WorkerStats>, Condvar)>, +} + +#[cfg(test)] +#[derive(Default)] +struct WorkerStats { + dropped: u32, + sent: u32, + handled: u32, +} + +#[derive(Debug, Clone)] +enum CacheEvent { + OnCacheGet(PathBuf), + OnCacheUpdate(PathBuf), +} + +impl Worker { + pub(super) fn start_new( + cache_config: &CacheConfig, + init_file_per_thread_logger: Option<&'static str>, + ) -> Self { + let queue_size = match cache_config.worker_event_queue_size() { + num if num <= usize::max_value() as u64 => num as usize, + _ => usize::max_value(), + }; + let (tx, rx) = sync_channel(queue_size); + + #[cfg(test)] + let stats = Arc::new((Mutex::new(WorkerStats::default()), Condvar::new())); + + let worker_thread = WorkerThread { + receiver: rx, + cache_config: cache_config.clone(), + #[cfg(test)] + stats: stats.clone(), + }; + + // when self is dropped, sender will be dropped, what will cause the channel + // to hang, and the worker thread to exit -- it happens in the tests + // non-tests binary has only a static worker, so Rust doesn't drop it + thread::spawn(move || worker_thread.run(init_file_per_thread_logger)); + + Self { + sender: tx, + #[cfg(test)] + stats, + } + } + + pub(super) fn on_cache_get_async(&self, path: impl AsRef<Path>) { + let event = CacheEvent::OnCacheGet(path.as_ref().to_path_buf()); + self.send_cache_event(event); + } + + pub(super) fn on_cache_update_async(&self, path: impl AsRef<Path>) { + let event = CacheEvent::OnCacheUpdate(path.as_ref().to_path_buf()); + self.send_cache_event(event); + } + + #[inline] + fn send_cache_event(&self, event: CacheEvent) { + let sent_event = self.sender.try_send(event.clone()); + + if let Err(ref err) = sent_event { + info!( + "Failed to send asynchronously message to worker thread, \ + event: {:?}, error: {}", + event, err + ); + } + + #[cfg(test)] + { + let mut stats = self + .stats + .0 + .lock() + .expect("Failed to acquire worker stats lock"); + + if sent_event.is_ok() { + stats.sent += 1; + } else { + stats.dropped += 1; + } + } + } + + #[cfg(test)] + pub(super) fn events_dropped(&self) -> u32 { + let stats = self + .stats + .0 + .lock() + .expect("Failed to acquire worker stats lock"); + stats.dropped + } + + #[cfg(test)] + pub(super) fn wait_for_all_events_handled(&self) { + let (stats, condvar) = &*self.stats; + let mut stats = stats.lock().expect("Failed to acquire worker stats lock"); + while stats.handled != stats.sent { + stats = condvar + .wait(stats) + .expect("Failed to reacquire worker stats lock"); + } + } +} + +impl fmt::Debug for Worker { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Worker").finish() + } +} + +#[derive(Serialize, Deserialize)] +struct ModuleCacheStatistics { + pub usages: u64, + #[serde(rename = "optimized-compression")] + pub compression_level: i32, +} + +impl ModuleCacheStatistics { + fn default(cache_config: &CacheConfig) -> Self { + Self { + usages: 0, + compression_level: cache_config.baseline_compression_level(), + } + } +} + +enum CacheEntry { + Recognized { + path: PathBuf, + mtime: SystemTime, + size: u64, + }, + Unrecognized { + path: PathBuf, + is_dir: bool, + }, +} + +macro_rules! unwrap_or_warn { + ($result:expr, $cont:stmt, $err_msg:expr, $path:expr) => { + match $result { + Ok(val) => val, + Err(err) => { + warn!("{}, path: {}, msg: {}", $err_msg, $path.display(), err); + $cont + } + } + }; +} + +impl WorkerThread { + fn run(self, init_file_per_thread_logger: Option<&'static str>) { + if let Some(prefix) = init_file_per_thread_logger { + file_per_thread_logger::initialize(prefix); + } + + debug!("Cache worker thread started."); + + Self::lower_thread_priority(); + + #[cfg(test)] + let (stats, condvar) = &*self.stats; + + for event in self.receiver.iter() { + match event { + CacheEvent::OnCacheGet(path) => self.handle_on_cache_get(path), + CacheEvent::OnCacheUpdate(path) => self.handle_on_cache_update(path), + } + + #[cfg(test)] + { + let mut stats = stats.lock().expect("Failed to acquire worker stats lock"); + stats.handled += 1; + condvar.notify_all(); + } + } + } + + #[cfg(target_os = "windows")] + fn lower_thread_priority() { + use std::convert::TryInto; + use winapi::um::processthreadsapi::{GetCurrentThread, SetThreadPriority}; + use winapi::um::winbase::THREAD_MODE_BACKGROUND_BEGIN; + + // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setthreadpriority + // https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities + + if unsafe { + SetThreadPriority( + GetCurrentThread(), + THREAD_MODE_BACKGROUND_BEGIN.try_into().unwrap(), + ) + } == 0 + { + warn!( + "Failed to lower worker thread priority. It might affect application performance." + ); + } + } + + #[cfg(not(target_os = "windows"))] + fn lower_thread_priority() { + // http://man7.org/linux/man-pages/man7/sched.7.html + + const NICE_DELTA_FOR_BACKGROUND_TASKS: i32 = 3; + + errno::set_errno(errno::Errno(0)); + let current_nice = unsafe { libc::nice(NICE_DELTA_FOR_BACKGROUND_TASKS) }; + let errno_val = errno::errno().0; + + if errno_val != 0 { + warn!( + "Failed to lower worker thread priority. It might affect application performance. \ + errno: {}", + errno_val + ); + } else { + debug!("New nice value of worker thread: {}", current_nice); + } + } + + /// Increases the usage counter and recompresses the file + /// if the usage counter reached configurable treshold. + fn handle_on_cache_get(&self, path: PathBuf) { + trace!("handle_on_cache_get() for path: {}", path.display()); + + // construct .stats file path + let filename = path.file_name().unwrap().to_str().unwrap(); + let stats_path = path.with_file_name(format!("{}.stats", filename)); + + // load .stats file (default if none or error) + let mut stats = read_stats_file(stats_path.as_ref()) + .unwrap_or_else(|| ModuleCacheStatistics::default(&self.cache_config)); + + // step 1: update the usage counter & write to the disk + // it's racy, but it's fine (the counter will be just smaller, + // sometimes will retrigger recompression) + stats.usages += 1; + if !write_stats_file(stats_path.as_ref(), &stats) { + return; + } + + // step 2: recompress if there's a need + let opt_compr_lvl = self.cache_config.optimized_compression_level(); + if stats.compression_level >= opt_compr_lvl + || stats.usages + < self + .cache_config + .optimized_compression_usage_counter_threshold() + { + return; + } + + let lock_path = if let Some(p) = acquire_task_fs_lock( + path.as_ref(), + self.cache_config.optimizing_compression_task_timeout(), + self.cache_config + .allowed_clock_drift_for_files_from_future(), + ) { + p + } else { + return; + }; + + trace!("Trying to recompress file: {}", path.display()); + + // recompress, write to other file, rename (it's atomic file content exchange) + // and update the stats file + let compressed_cache_bytes = unwrap_or_warn!( + fs::read(&path), + return, + "Failed to read old cache file", + path + ); + + let cache_bytes = unwrap_or_warn!( + zstd::decode_all(&compressed_cache_bytes[..]), + return, + "Failed to decompress cached code", + path + ); + + let recompressed_cache_bytes = unwrap_or_warn!( + zstd::encode_all(&cache_bytes[..], opt_compr_lvl), + return, + "Failed to compress cached code", + path + ); + + unwrap_or_warn!( + fs::write(&lock_path, &recompressed_cache_bytes), + return, + "Failed to write recompressed cache", + lock_path + ); + + unwrap_or_warn!( + fs::rename(&lock_path, &path), + { + if let Err(error) = fs::remove_file(&lock_path) { + warn!( + "Failed to clean up (remove) recompressed cache, path {}, err: {}", + lock_path.display(), + error + ); + } + + return; + }, + "Failed to rename recompressed cache", + lock_path + ); + + // update stats file (reload it! recompression can take some time) + if let Some(mut new_stats) = read_stats_file(stats_path.as_ref()) { + if new_stats.compression_level >= opt_compr_lvl { + // Rare race: + // two instances with different opt_compr_lvl: we don't know in which order they updated + // the cache file and the stats file (they are not updated together atomically) + // Possible solution is to use directories per cache entry, but it complicates the system + // and is not worth it. + debug!( + "DETECTED task did more than once (or race with new file): \ + recompression of {}. Note: if optimized compression level setting \ + has changed in the meantine, the stats file might contain \ + inconsistent compression level due to race.", + path.display() + ); + } else { + new_stats.compression_level = opt_compr_lvl; + let _ = write_stats_file(stats_path.as_ref(), &new_stats); + } + + if new_stats.usages < stats.usages { + debug!( + "DETECTED lower usage count (new file or race with counter \ + increasing): file {}", + path.display() + ); + } + } else { + debug!( + "Can't read stats file again to update compression level (it might got \ + cleaned up): file {}", + stats_path.display() + ); + } + + trace!("Task finished: recompress file: {}", path.display()); + } + + fn handle_on_cache_update(&self, path: PathBuf) { + trace!("handle_on_cache_update() for path: {}", path.display()); + + // ---------------------- step 1: create .stats file + + // construct .stats file path + let filename = path + .file_name() + .expect("Expected valid cache file name") + .to_str() + .expect("Expected valid cache file name"); + let stats_path = path.with_file_name(format!("{}.stats", filename)); + + // create and write stats file + let mut stats = ModuleCacheStatistics::default(&self.cache_config); + stats.usages += 1; + write_stats_file(&stats_path, &stats); + + // ---------------------- step 2: perform cleanup task if needed + + // acquire lock for cleanup task + // Lock is a proof of recent cleanup task, so we don't want to delete them. + // Expired locks will be deleted by the cleanup task. + let cleanup_file = self.cache_config.directory().join(".cleanup"); // some non existing marker file + if acquire_task_fs_lock( + &cleanup_file, + self.cache_config.cleanup_interval(), + self.cache_config + .allowed_clock_drift_for_files_from_future(), + ) + .is_none() + { + return; + } + + trace!("Trying to clean up cache"); + + let mut cache_index = self.list_cache_contents(); + let future_tolerance = SystemTime::now() + .checked_add( + self.cache_config + .allowed_clock_drift_for_files_from_future(), + ) + .expect("Brace your cache, the next Big Bang is coming (time overflow)"); + cache_index.sort_unstable_by(|lhs, rhs| { + // sort by age + use CacheEntry::*; + match (lhs, rhs) { + (Recognized { mtime: lhs_mt, .. }, Recognized { mtime: rhs_mt, .. }) => { + match (*lhs_mt > future_tolerance, *rhs_mt > future_tolerance) { + // later == younger + (false, false) => rhs_mt.cmp(lhs_mt), + // files from far future are treated as oldest recognized files + // we want to delete them, so the cache keeps track of recent files + // however, we don't delete them uncodintionally, + // because .stats file can be overwritten with a meaningful mtime + (true, false) => cmp::Ordering::Greater, + (false, true) => cmp::Ordering::Less, + (true, true) => cmp::Ordering::Equal, + } + } + // unrecognized is kind of infinity + (Recognized { .. }, Unrecognized { .. }) => cmp::Ordering::Less, + (Unrecognized { .. }, Recognized { .. }) => cmp::Ordering::Greater, + (Unrecognized { .. }, Unrecognized { .. }) => cmp::Ordering::Equal, + } + }); + + // find "cut" boundary: + // - remove unrecognized files anyway, + // - remove some cache files if some quota has been exceeded + let mut total_size = 0u64; + let mut start_delete_idx = None; + let mut start_delete_idx_if_deleting_recognized_items: Option<usize> = None; + + let total_size_limit = self.cache_config.files_total_size_soft_limit(); + let file_count_limit = self.cache_config.file_count_soft_limit(); + let tsl_if_deleting = total_size_limit + .checked_mul( + self.cache_config + .files_total_size_limit_percent_if_deleting() as u64, + ) + .unwrap() + / 100; + let fcl_if_deleting = file_count_limit + .checked_mul(self.cache_config.file_count_limit_percent_if_deleting() as u64) + .unwrap() + / 100; + + for (idx, item) in cache_index.iter().enumerate() { + let size = if let CacheEntry::Recognized { size, .. } = item { + size + } else { + start_delete_idx = Some(idx); + break; + }; + + total_size += size; + if start_delete_idx_if_deleting_recognized_items.is_none() + && (total_size > tsl_if_deleting || (idx + 1) as u64 > fcl_if_deleting) + { + start_delete_idx_if_deleting_recognized_items = Some(idx); + } + + if total_size > total_size_limit || (idx + 1) as u64 > file_count_limit { + start_delete_idx = start_delete_idx_if_deleting_recognized_items; + break; + } + } + + if let Some(idx) = start_delete_idx { + for item in &cache_index[idx..] { + let (result, path, entity) = match item { + CacheEntry::Recognized { path, .. } + | CacheEntry::Unrecognized { + path, + is_dir: false, + } => (fs::remove_file(path), path, "file"), + CacheEntry::Unrecognized { path, is_dir: true } => { + (fs::remove_dir_all(path), path, "directory") + } + }; + if let Err(err) = result { + warn!( + "Failed to remove {} during cleanup, path: {}, err: {}", + entity, + path.display(), + err + ); + } + } + } + + trace!("Task finished: clean up cache"); + } + + // Be fault tolerant: list as much as you can, and ignore the rest + fn list_cache_contents(&self) -> Vec<CacheEntry> { + fn enter_dir( + vec: &mut Vec<CacheEntry>, + dir_path: &Path, + level: u8, + cache_config: &CacheConfig, + ) { + macro_rules! add_unrecognized { + (file: $path:expr) => { + add_unrecognized!(false, $path) + }; + (dir: $path:expr) => { + add_unrecognized!(true, $path) + }; + ($is_dir:expr, $path:expr) => { + vec.push(CacheEntry::Unrecognized { + path: $path.to_path_buf(), + is_dir: $is_dir, + }); + }; + } + macro_rules! add_unrecognized_and { + ([ $( $ty:ident: $path:expr ),* ], $cont:stmt) => {{ + $( add_unrecognized!($ty: $path); )* + $cont + }}; + } + + macro_rules! unwrap_or { + ($result:expr, $cont:stmt, $err_msg:expr) => { + unwrap_or!($result, $cont, $err_msg, dir_path) + }; + ($result:expr, $cont:stmt, $err_msg:expr, $path:expr) => { + unwrap_or_warn!( + $result, + $cont, + format!("{}, level: {}", $err_msg, level), + $path + ) + }; + } + + // If we fail to list a directory, something bad is happening anyway + // (something touches our cache or we have disk failure) + // Try to delete it, so we can stay within soft limits of the cache size. + // This comment applies later in this function, too. + let it = unwrap_or!( + fs::read_dir(dir_path), + add_unrecognized_and!([dir: dir_path], return), + "Failed to list cache directory, deleting it" + ); + + let mut cache_files = HashMap::new(); + for entry in it { + // read_dir() returns an iterator over results - in case some of them are errors + // we don't know their names, so we can't delete them. We don't want to delete + // the whole directory with good entries too, so we just ignore the erroneous entries. + let entry = unwrap_or!( + entry, + continue, + "Failed to read a cache dir entry (NOT deleting it, it still occupies space)" + ); + let path = entry.path(); + match (level, path.is_dir()) { + (0..=1, true) => enter_dir(vec, &path, level + 1, cache_config), + (0..=1, false) => { + if level == 0 + && path.file_stem() == Some(OsStr::new(".cleanup")) + && path.extension().is_some() + // assume it's cleanup lock + && !is_fs_lock_expired( + Some(&entry), + &path, + cache_config.cleanup_interval(), + cache_config.allowed_clock_drift_for_files_from_future(), + ) + { + continue; // skip active lock + } + add_unrecognized!(file: path); + } + (2, false) => { + match path.extension().and_then(OsStr::to_str) { + // mod or stats file + None | Some("stats") => { + cache_files.insert(path, entry); + } + + Some(ext) => { + // check if valid lock + let recognized = ext.starts_with("wip-") + && !is_fs_lock_expired( + Some(&entry), + &path, + cache_config.optimizing_compression_task_timeout(), + cache_config.allowed_clock_drift_for_files_from_future(), + ); + + if !recognized { + add_unrecognized!(file: path); + } + } + } + } + (_, is_dir) => add_unrecognized!(is_dir, path), + } + } + + // associate module with its stats & handle them + // assumption: just mods and stats + for (path, entry) in cache_files.iter() { + let path_buf: PathBuf; + let (mod_, stats_, is_mod) = match path.extension() { + Some(_) => { + path_buf = path.with_extension(""); + ( + cache_files.get(&path_buf).map(|v| (&path_buf, v)), + Some((path, entry)), + false, + ) + } + None => { + path_buf = path.with_extension("stats"); + ( + Some((path, entry)), + cache_files.get(&path_buf).map(|v| (&path_buf, v)), + true, + ) + } + }; + + // construct a cache entry + match (mod_, stats_, is_mod) { + (Some((mod_path, mod_entry)), Some((stats_path, stats_entry)), true) => { + let mod_metadata = unwrap_or!( + mod_entry.metadata(), + add_unrecognized_and!([file: stats_path, file: mod_path], continue), + "Failed to get metadata, deleting BOTH module cache and stats files", + mod_path + ); + let stats_mtime = unwrap_or!( + stats_entry.metadata().and_then(|m| m.modified()), + add_unrecognized_and!( + [file: stats_path], + unwrap_or!( + mod_metadata.modified(), + add_unrecognized_and!( + [file: stats_path, file: mod_path], + continue + ), + "Failed to get mtime, deleting BOTH module cache and stats \ + files", + mod_path + ) + ), + "Failed to get metadata/mtime, deleting the file", + stats_path + ); + // .into() called for the SystemTimeStub if cfg(test) + #[allow(clippy::identity_conversion)] + vec.push(CacheEntry::Recognized { + path: mod_path.to_path_buf(), + mtime: stats_mtime.into(), + size: mod_metadata.len(), + }) + } + (Some(_), Some(_), false) => (), // was or will be handled by previous branch + (Some((mod_path, mod_entry)), None, _) => { + let (mod_metadata, mod_mtime) = unwrap_or!( + mod_entry + .metadata() + .and_then(|md| md.modified().map(|mt| (md, mt))), + add_unrecognized_and!([file: mod_path], continue), + "Failed to get metadata/mtime, deleting the file", + mod_path + ); + // .into() called for the SystemTimeStub if cfg(test) + #[allow(clippy::identity_conversion)] + vec.push(CacheEntry::Recognized { + path: mod_path.to_path_buf(), + mtime: mod_mtime.into(), + size: mod_metadata.len(), + }) + } + (None, Some((stats_path, _stats_entry)), _) => { + debug!("Found orphaned stats file: {}", stats_path.display()); + add_unrecognized!(file: stats_path); + } + _ => unreachable!(), + } + } + } + + let mut vec = Vec::new(); + enter_dir( + &mut vec, + self.cache_config.directory(), + 0, + &self.cache_config, + ); + vec + } +} + +fn read_stats_file(path: &Path) -> Option<ModuleCacheStatistics> { + fs::read(path) + .map_err(|err| { + trace!( + "Failed to read stats file, path: {}, err: {}", + path.display(), + err + ) + }) + .and_then(|bytes| { + toml::from_slice::<ModuleCacheStatistics>(&bytes[..]).map_err(|err| { + trace!( + "Failed to parse stats file, path: {}, err: {}", + path.display(), + err, + ) + }) + }) + .ok() +} + +fn write_stats_file(path: &Path, stats: &ModuleCacheStatistics) -> bool { + toml::to_string_pretty(&stats) + .map_err(|err| { + warn!( + "Failed to serialize stats file, path: {}, err: {}", + path.display(), + err + ) + }) + .and_then(|serialized| { + if fs_write_atomic(path, "stats", serialized.as_bytes()) { + Ok(()) + } else { + Err(()) + } + }) + .is_ok() +} + +/// Tries to acquire a lock for specific task. +/// +/// Returns Some(path) to the lock if succeeds. The task path must not +/// contain any extension and have file stem. +/// +/// To release a lock you need either manually rename or remove it, +/// or wait until it expires and cleanup task removes it. +/// +/// Note: this function is racy. Main idea is: be fault tolerant and +/// never block some task. The price is that we rarely do some task +/// more than once. +fn acquire_task_fs_lock( + task_path: &Path, + timeout: Duration, + allowed_future_drift: Duration, +) -> Option<PathBuf> { + assert!(task_path.extension().is_none()); + assert!(task_path.file_stem().is_some()); + + // list directory + let dir_path = task_path.parent()?; + let it = fs::read_dir(dir_path) + .map_err(|err| { + warn!( + "Failed to list cache directory, path: {}, err: {}", + dir_path.display(), + err + ) + }) + .ok()?; + + // look for existing locks + for entry in it { + let entry = entry + .map_err(|err| { + warn!( + "Failed to list cache directory, path: {}, err: {}", + dir_path.display(), + err + ) + }) + .ok()?; + + let path = entry.path(); + if path.is_dir() || path.file_stem() != task_path.file_stem() { + continue; + } + + // check extension and mtime + match path.extension() { + None => continue, + Some(ext) => { + if let Some(ext_str) = ext.to_str() { + // if it's None, i.e. not valid UTF-8 string, then that's not our lock for sure + if ext_str.starts_with("wip-") + && !is_fs_lock_expired(Some(&entry), &path, timeout, allowed_future_drift) + { + return None; + } + } + } + } + } + + // create the lock + let lock_path = task_path.with_extension(format!("wip-{}", std::process::id())); + let _file = fs::OpenOptions::new() + .create_new(true) + .write(true) + .open(&lock_path) + .map_err(|err| { + warn!( + "Failed to create lock file (note: it shouldn't exists): path: {}, err: {}", + lock_path.display(), + err + ) + }) + .ok()?; + + Some(lock_path) +} + +// we have either both, or just path; dir entry is desirable since on some platforms we can get +// metadata without extra syscalls +// futhermore: it's better to get a path if we have it instead of allocating a new one from the dir entry +fn is_fs_lock_expired( + entry: Option<&fs::DirEntry>, + path: &PathBuf, + threshold: Duration, + allowed_future_drift: Duration, +) -> bool { + let mtime = match entry + .map_or_else(|| path.metadata(), |e| e.metadata()) + .and_then(|metadata| metadata.modified()) + { + Ok(mt) => mt, + Err(err) => { + warn!( + "Failed to get metadata/mtime, treating as an expired lock, path: {}, err: {}", + path.display(), + err + ); + return true; // can't read mtime, treat as expired, so this task will not be starved + } + }; + + // DON'T use: mtime.elapsed() -- we must call SystemTime directly for the tests to be deterministic + match SystemTime::now().duration_since(mtime) { + Ok(elapsed) => elapsed >= threshold, + Err(err) => { + trace!( + "Found mtime in the future, treating as a not expired lock, path: {}, err: {}", + path.display(), + err + ); + // the lock is expired if the time is too far in the future + // it is fine to have network share and not synchronized clocks, + // but it's not good when user changes time in their system clock + err.duration() > allowed_future_drift + } + } +} + +#[cfg(test)] +mod tests; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +
+//! A `Compilation` contains the compiled function bodies for a WebAssembly +//! module. + +use crate::cache::ModuleCacheDataTupleType; +use crate::module; +use crate::module_environ::FunctionBodyData; +use crate::CacheConfig; +use cranelift_codegen::{binemit, ir, isa, Context}; +use cranelift_entity::PrimaryMap; +use cranelift_wasm::{DefinedFuncIndex, FuncIndex, ModuleTranslationState, WasmError}; +use serde::{Deserialize, Serialize}; +use std::ops::Range; +use thiserror::Error; + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct FDERelocEntry(pub i64, pub usize, pub u8); + +/// Relocation entry for unwind info. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct CompiledFunctionUnwindInfoReloc { + /// Entry offest in the code block. + pub offset: u32, + /// Entry addend relative to the code block. + pub addend: u32, +} + +/// Compiled function unwind information. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub enum CompiledFunctionUnwindInfo { + /// No info. + None, + /// Windows UNWIND_INFO. + Windows(Vec<u8>), + /// Frame layout info. + FrameLayout(Vec<u8>, usize, Vec<FDERelocEntry>), +} + +impl CompiledFunctionUnwindInfo { + /// Constructs unwind info object. + pub fn new(isa: &dyn isa::TargetIsa, context: &Context) -> Self { + use cranelift_codegen::binemit::{ + FrameUnwindKind, FrameUnwindOffset, FrameUnwindSink, Reloc, + }; + use cranelift_codegen::isa::CallConv; + + struct Sink(Vec<u8>, usize, Vec<FDERelocEntry>); + impl FrameUnwindSink for Sink { + fn len(&self) -> FrameUnwindOffset { + self.0.len() + } + fn bytes(&mut self, b: &[u8]) { + self.0.extend_from_slice(b); + } + fn reserve(&mut self, len: usize) { + self.0.reserve(len) + } + fn reloc(&mut self, r: Reloc, off: FrameUnwindOffset) { + self.2.push(FDERelocEntry( + 0, + off, + match r { + Reloc::Abs4 => 4, + Reloc::Abs8 => 8, + _ => { + panic!("unexpected reloc type"); + } + }, + )) + } + fn set_entry_offset(&mut self, off: FrameUnwindOffset) { + self.1 = off; + } + } + + let kind = match context.func.signature.call_conv { + CallConv::SystemV | CallConv::Fast | CallConv::Cold => FrameUnwindKind::Libunwind, + CallConv::WindowsFastcall => FrameUnwindKind::Fastcall, + _ => { + return CompiledFunctionUnwindInfo::None; + } + }; + + let mut sink = Sink(Vec::new(), 0, Vec::new()); + context.emit_unwind_info(isa, kind, &mut sink); + + let Sink(data, offset, relocs) = sink; + if data.is_empty() { + return CompiledFunctionUnwindInfo::None; + } + + match kind { + FrameUnwindKind::Fastcall => CompiledFunctionUnwindInfo::Windows(data), + FrameUnwindKind::Libunwind => { + CompiledFunctionUnwindInfo::FrameLayout(data, offset, relocs) + } + } + } + + /// Retuns true is no unwind info data. + pub fn is_empty(&self) -> bool { + match self { + CompiledFunctionUnwindInfo::None => true, + CompiledFunctionUnwindInfo::Windows(d) => d.is_empty(), + CompiledFunctionUnwindInfo::FrameLayout(c, _, _) => c.is_empty(), + } + } + + /// Returns size of serilized unwind info. + pub fn len(&self) -> usize { + match self { + CompiledFunctionUnwindInfo::None => 0, + CompiledFunctionUnwindInfo::Windows(d) => d.len(), + CompiledFunctionUnwindInfo::FrameLayout(c, _, _) => c.len(), + } + } + + /// Serializes data into byte array. + pub fn serialize(&self, dest: &mut [u8], relocs: &mut Vec<CompiledFunctionUnwindInfoReloc>) { + match self { + CompiledFunctionUnwindInfo::None => (), + CompiledFunctionUnwindInfo::Windows(d) => { + dest.copy_from_slice(d); + } + CompiledFunctionUnwindInfo::FrameLayout(code, _fde_offset, r) => { + dest.copy_from_slice(code); + r.iter().for_each(move |r| { + assert_eq!(r.2, 8); + relocs.push(CompiledFunctionUnwindInfoReloc { + offset: r.1 as u32, + addend: r.0 as u32, + }) + }); + } + } + } +} + +/// Compiled function: machine code body, jump table offsets, and unwind information. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct CompiledFunction { + /// The function body. + pub body: Vec<u8>, + + /// The jump tables offsets (in the body). + pub jt_offsets: ir::JumpTableOffsets, + + /// The unwind information. + pub unwind_info: CompiledFunctionUnwindInfo, +} + +type Functions = PrimaryMap<DefinedFuncIndex, CompiledFunction>; + +/// The result of compiling a WebAssembly module's functions. +#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)] +pub struct Compilation { + /// Compiled machine code for the function bodies. + functions: Functions, +} + +impl Compilation { + /// Creates a compilation artifact from a contiguous function buffer and a set of ranges + pub fn new(functions: Functions) -> Self { + Self { functions } + } + + /// Allocates the compilation result with the given function bodies. + pub fn from_buffer( + buffer: Vec<u8>, + functions: impl IntoIterator<Item = (Range<usize>, ir::JumpTableOffsets, Range<usize>)>, + ) -> Self { + Self::new( + functions + .into_iter() + .map(|(body_range, jt_offsets, unwind_range)| CompiledFunction { + body: buffer[body_range].to_vec(), + jt_offsets, + unwind_info: CompiledFunctionUnwindInfo::Windows(buffer[unwind_range].to_vec()), + }) + .collect(), + ) + } + + /// Gets the bytes of a single function + pub fn get(&self, func: DefinedFuncIndex) -> &CompiledFunction { + &self.functions[func] + } + + /// Gets the number of functions defined. + pub fn len(&self) -> usize { + self.functions.len() + } + + /// Returns whether there are no functions defined. + pub fn is_empty(&self) -> bool { + self.functions.is_empty() + } + + /// Gets functions jump table offsets. + pub fn get_jt_offsets(&self) -> PrimaryMap<DefinedFuncIndex, ir::JumpTableOffsets> { + self.functions + .iter() + .map(|(_, func)| func.jt_offsets.clone()) + .collect::<PrimaryMap<DefinedFuncIndex, _>>() + } +} + +impl<'a> IntoIterator for &'a Compilation { + type IntoIter = Iter<'a>; + type Item = <Self::IntoIter as Iterator>::Item; + + fn into_iter(self) -> Self::IntoIter { + Iter { + iterator: self.functions.iter(), + } + } +} + +pub struct Iter<'a> { + iterator: <&'a Functions as IntoIterator>::IntoIter, +} + +impl<'a> Iterator for Iter<'a> { + type Item = &'a CompiledFunction; + + fn next(&mut self) -> Option<Self::Item> { + self.iterator.next().map(|(_, b)| b) + } +} + +/// A record of a relocation to perform. +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] +pub struct Relocation { + /// The relocation code. + pub reloc: binemit::Reloc, + /// Relocation target. + pub reloc_target: RelocationTarget, + /// The offset where to apply the relocation. + pub offset: binemit::CodeOffset, + /// The addend to add to the relocation value. + pub addend: binemit::Addend, +} + +/// Destination function. Can be either user function or some special one, like `memory.grow`. +#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)] +pub enum RelocationTarget { + /// The user function index. + UserFunc(FuncIndex), + /// A compiler-generated libcall. + LibCall(ir::LibCall), + /// Jump table index. + JumpTable(FuncIndex, ir::JumpTable), +} + +/// Relocations to apply to function bodies. +pub type Relocations = PrimaryMap<DefinedFuncIndex, Vec<Relocation>>; + +/// Information about trap. +#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)] +pub struct TrapInformation { + /// The offset of the trapping instruction in native code. It is relative to the beginning of the function. + pub code_offset: binemit::CodeOffset, + /// Location of trapping instruction in WebAssembly binary module. + pub source_loc: ir::SourceLoc, + /// Code of the trap. + pub trap_code: ir::TrapCode, +} + +/// Information about traps associated with the functions where the traps are placed. +pub type Traps = PrimaryMap<DefinedFuncIndex, Vec<TrapInformation>>; + +/// An error while compiling WebAssembly to machine code. +#[derive(Error, Debug)] +pub enum CompileError { + /// A wasm translation error occured. + #[error("WebAssembly translation error")] + Wasm(#[from] WasmError), + + /// A compilation error occured. + #[error("Compilation error: {0}")] + Codegen(String), + + /// A compilation error occured. + #[error("Debug info is not supported with this configuration")] + DebugInfoNotSupported, +} + +/// An implementation of a compiler from parsed WebAssembly module to native code. +pub trait Compiler { + /// Compile a parsed module with the given `TargetIsa`. + fn compile_module<'data, 'module>( + module: &'module module::Module, + module_translation: &ModuleTranslationState, + function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + isa: &dyn isa::TargetIsa, + generate_debug_info: bool, + cache_config: &CacheConfig, + ) -> Result<ModuleCacheDataTupleType, CompileError>; +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +
+//! Support for compiling with Cranelift. + +use crate::address_map::{FunctionAddressMap, InstructionAddressMap}; +use crate::cache::{ModuleCacheData, ModuleCacheDataTupleType, ModuleCacheEntry}; +use crate::compilation::{ + Compilation, CompileError, CompiledFunction, CompiledFunctionUnwindInfo, Relocation, + RelocationTarget, TrapInformation, +}; +use crate::func_environ::{get_func_name, FuncEnvironment}; +use crate::module::Module; +use crate::module_environ::FunctionBodyData; +use crate::CacheConfig; +use cranelift_codegen::ir::{self, ExternalName}; +use cranelift_codegen::print_errors::pretty_error; +use cranelift_codegen::{binemit, isa, Context}; +use cranelift_entity::PrimaryMap; +use cranelift_wasm::{DefinedFuncIndex, FuncIndex, FuncTranslator, ModuleTranslationState}; +use rayon::prelude::{IntoParallelRefIterator, ParallelIterator}; + +/// Implementation of a relocation sink that just saves all the information for later +pub struct RelocSink { + /// Current function index. + func_index: FuncIndex, + + /// Relocations recorded for the function. + pub func_relocs: Vec<Relocation>, +} + +impl binemit::RelocSink for RelocSink { + fn reloc_block( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _block_offset: binemit::CodeOffset, + ) { + // This should use the `offsets` field of `ir::Function`. + panic!("block headers not yet implemented"); + } + fn reloc_external( + &mut self, + offset: binemit::CodeOffset, + reloc: binemit::Reloc, + name: &ExternalName, + addend: binemit::Addend, + ) { + let reloc_target = if let ExternalName::User { namespace, index } = *name { + debug_assert_eq!(namespace, 0); + RelocationTarget::UserFunc(FuncIndex::from_u32(index)) + } else if let ExternalName::LibCall(libcall) = *name { + RelocationTarget::LibCall(libcall) + } else { + panic!("unrecognized external name") + }; + self.func_relocs.push(Relocation { + reloc, + reloc_target, + offset, + addend, + }); + } + + fn reloc_constant( + &mut self, + _code_offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _constant_offset: ir::ConstantOffset, + ) { + // Do nothing for now: cranelift emits constant data after the function code and also emits + // function code with correct relative offsets to the constant data. + } + + fn reloc_jt(&mut self, offset: binemit::CodeOffset, reloc: binemit::Reloc, jt: ir::JumpTable) { + self.func_relocs.push(Relocation { + reloc, + reloc_target: RelocationTarget::JumpTable(self.func_index, jt), + offset, + addend: 0, + }); + } +} + +impl RelocSink { + /// Return a new `RelocSink` instance. + pub fn new(func_index: FuncIndex) -> Self { + Self { + func_index, + func_relocs: Vec::new(), + } + } +} + +struct TrapSink { + pub traps: Vec<TrapInformation>, +} + +impl TrapSink { + fn new() -> Self { + Self { traps: Vec::new() } + } +} + +impl binemit::TrapSink for TrapSink { + fn trap( + &mut self, + code_offset: binemit::CodeOffset, + source_loc: ir::SourceLoc, + trap_code: ir::TrapCode, + ) { + self.traps.push(TrapInformation { + code_offset, + source_loc, + trap_code, + }); + } +} + +fn get_function_address_map<'data>( + context: &Context, + data: &FunctionBodyData<'data>, + body_len: usize, + isa: &dyn isa::TargetIsa, +) -> FunctionAddressMap { + let mut instructions = Vec::new(); + + let func = &context.func; + let mut blocks = func.layout.blocks().collect::<Vec<_>>(); + blocks.sort_by_key(|block| func.offsets[*block]); // Ensure inst offsets always increase + + let encinfo = isa.encoding_info(); + for block in blocks { + for (offset, inst, size) in func.inst_offsets(block, &encinfo) { + let srcloc = func.srclocs[inst]; + instructions.push(InstructionAddressMap { + srcloc, + code_offset: offset as usize, + code_len: size as usize, + }); + } + } + + // Generate artificial srcloc for function start/end to identify boundary + // within module. Similar to FuncTranslator::cur_srcloc(): it will wrap around + // if byte code is larger than 4 GB. + let start_srcloc = ir::SourceLoc::new(data.module_offset as u32); + let end_srcloc = ir::SourceLoc::new((data.module_offset + data.data.len()) as u32); + + FunctionAddressMap { + instructions, + start_srcloc, + end_srcloc, + body_offset: 0, + body_len, + } +} + +/// A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR, +/// optimizing it and then translating to assembly. +pub struct Cranelift; + +impl crate::compilation::Compiler for Cranelift { + /// Compile the module using Cranelift, producing a compilation result with + /// associated relocations. + fn compile_module<'data, 'module>( + module: &'module Module, + module_translation: &ModuleTranslationState, + function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + isa: &dyn isa::TargetIsa, + generate_debug_info: bool, + cache_config: &CacheConfig, + ) -> Result<ModuleCacheDataTupleType, CompileError> { + let cache_entry = ModuleCacheEntry::new( + module, + &function_body_inputs, + isa, + "cranelift", + generate_debug_info, + cache_config, + ); + + let data = match cache_entry.get_data() { + Some(data) => data, + None => { + let mut functions = PrimaryMap::with_capacity(function_body_inputs.len()); + let mut relocations = PrimaryMap::with_capacity(function_body_inputs.len()); + let mut address_transforms = PrimaryMap::with_capacity(function_body_inputs.len()); + let mut value_ranges = PrimaryMap::with_capacity(function_body_inputs.len()); + let mut stack_slots = PrimaryMap::with_capacity(function_body_inputs.len()); + let mut traps = PrimaryMap::with_capacity(function_body_inputs.len()); + + function_body_inputs + .into_iter() + .collect::<Vec<(DefinedFuncIndex, &FunctionBodyData<'data>)>>() + .par_iter() + .map_init(FuncTranslator::new, |func_translator, (i, input)| { + let func_index = module.func_index(*i); + let mut context = Context::new(); + context.func.name = get_func_name(func_index); + context.func.signature = + module.signatures[module.functions[func_index]].clone(); + context.func.collect_frame_layout_info(); + if generate_debug_info { + context.func.collect_debug_info(); + } + + func_translator.translate( + module_translation, + input.data, + input.module_offset, + &mut context.func, + &mut FuncEnvironment::new(isa.frontend_config(), module), + )?; + + let mut code_buf: Vec<u8> = Vec::new(); + let mut reloc_sink = RelocSink::new(func_index); + let mut trap_sink = TrapSink::new(); + let mut stackmap_sink = binemit::NullStackmapSink {}; + context + .compile_and_emit( + isa, + &mut code_buf, + &mut reloc_sink, + &mut trap_sink, + &mut stackmap_sink, + ) + .map_err(|error| { + CompileError::Codegen(pretty_error(&context.func, Some(isa), error)) + })?; + + let unwind_info = CompiledFunctionUnwindInfo::new(isa, &context); + + let address_transform = if generate_debug_info { + let body_len = code_buf.len(); + Some(get_function_address_map(&context, input, body_len, isa)) + } else { + None + }; + + let ranges = if generate_debug_info { + let ranges = + context.build_value_labels_ranges(isa).map_err(|error| { + CompileError::Codegen(pretty_error( + &context.func, + Some(isa), + error, + )) + })?; + Some(ranges) + } else { + None + }; + + Ok(( + code_buf, + context.func.jt_offsets, + reloc_sink.func_relocs, + address_transform, + ranges, + context.func.stack_slots, + trap_sink.traps, + unwind_info, + )) + }) + .collect::<Result<Vec<_>, CompileError>>()? + .into_iter() + .for_each( + |( + function, + func_jt_offsets, + relocs, + address_transform, + ranges, + sss, + function_traps, + unwind_info, + )| { + functions.push(CompiledFunction { + body: function, + jt_offsets: func_jt_offsets, + unwind_info, + }); + relocations.push(relocs); + if let Some(address_transform) = address_transform { + address_transforms.push(address_transform); + } + value_ranges.push(ranges.unwrap_or_default()); + stack_slots.push(sss); + traps.push(function_traps); + }, + ); + + // TODO: Reorganize where we create the Vec for the resolved imports. + + let data = ModuleCacheData::from_tuple(( + Compilation::new(functions), + relocations, + address_transforms, + value_ranges, + stack_slots, + traps, + )); + cache_entry.update_data(&data); + data + } + }; + + Ok(data.into_tuple()) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +
+#![doc(hidden)] + +pub mod ir { + pub use cranelift_codegen::ir::{ + types, AbiParam, ArgumentPurpose, Signature, SourceLoc, StackSlots, TrapCode, Type, + ValueLabel, ValueLoc, + }; + pub use cranelift_codegen::ValueLabelsRanges; +} + +pub mod settings { + pub use cranelift_codegen::settings::{builder, Builder, Configurable, Flags}; +} + +pub mod isa { + pub use cranelift_codegen::isa::{CallConv, RegUnit, TargetFrontendConfig, TargetIsa}; +} + +pub mod entity { + pub use cranelift_entity::{BoxedSlice, EntityRef, PrimaryMap}; +} + +pub mod wasm { + pub use cranelift_wasm::{ + get_vmctx_value_label, DefinedFuncIndex, DefinedGlobalIndex, DefinedMemoryIndex, + DefinedTableIndex, FuncIndex, Global, GlobalIndex, GlobalInit, Memory, MemoryIndex, + SignatureIndex, Table, TableElementType, TableIndex, + }; +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +
+use crate::module::{MemoryPlan, MemoryStyle, Module, TableStyle}; +use crate::vmoffsets::VMOffsets; +use crate::WASM_PAGE_SIZE; +use cranelift_codegen::cursor::FuncCursor; +use cranelift_codegen::ir; +use cranelift_codegen::ir::condcodes::*; +use cranelift_codegen::ir::immediates::{Offset32, Uimm64}; +use cranelift_codegen::ir::types::*; +use cranelift_codegen::ir::{AbiParam, ArgumentPurpose, Function, InstBuilder, Signature}; +use cranelift_codegen::isa::TargetFrontendConfig; +use cranelift_entity::EntityRef; +use cranelift_wasm::{ + self, FuncIndex, GlobalIndex, GlobalVariable, MemoryIndex, SignatureIndex, TableIndex, + TargetEnvironment, WasmError, WasmResult, +}; +#[cfg(feature = "lightbeam")] +use cranelift_wasm::{DefinedFuncIndex, DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex}; +use std::convert::TryFrom; + +/// Compute an `ir::ExternalName` for a given wasm function index. +pub fn get_func_name(func_index: FuncIndex) -> ir::ExternalName { + ir::ExternalName::user(0, func_index.as_u32()) +} + +/// An index type for builtin functions. +pub struct BuiltinFunctionIndex(u32); + +impl BuiltinFunctionIndex { + /// Returns an index for wasm's `memory.grow` builtin function. + pub const fn get_memory32_grow_index() -> Self { + Self(0) + } + /// Returns an index for wasm's imported `memory.grow` builtin function. + pub const fn get_imported_memory32_grow_index() -> Self { + Self(1) + } + /// Returns an index for wasm's `memory.size` builtin function. + pub const fn get_memory32_size_index() -> Self { + Self(2) + } + /// Returns an index for wasm's imported `memory.size` builtin function. + pub const fn get_imported_memory32_size_index() -> Self { + Self(3) + } + /// Returns the total number of builtin functions. + pub const fn builtin_functions_total_number() -> u32 { + 4 + } + + /// Return the index as an u32 number. + pub const fn index(&self) -> u32 { + self.0 + } +} + +/// The `FuncEnvironment` implementation for use by the `ModuleEnvironment`. +pub struct FuncEnvironment<'module_environment> { + /// Target-specified configuration. + target_config: TargetFrontendConfig, + + /// The module-level environment which this function-level environment belongs to. + module: &'module_environment Module, + + /// The Cranelift global holding the vmctx address. + vmctx: Option<ir::GlobalValue>, + + /// The external function signature for implementing wasm's `memory.size` + /// for locally-defined 32-bit memories. + memory32_size_sig: Option<ir::SigRef>, + + /// The external function signature for implementing wasm's `memory.grow` + /// for locally-defined memories. + memory_grow_sig: Option<ir::SigRef>, + + /// Offsets to struct fields accessed by JIT code. + offsets: VMOffsets, +} + +impl<'module_environment> FuncEnvironment<'module_environment> { + pub fn new(target_config: TargetFrontendConfig, module: &'module_environment Module) -> Self { + Self { + target_config, + module, + vmctx: None, + memory32_size_sig: None, + memory_grow_sig: None, + offsets: VMOffsets::new(target_config.pointer_bytes(), module), + } + } + + fn pointer_type(&self) -> ir::Type { + self.target_config.pointer_type() + } + + fn vmctx(&mut self, func: &mut Function) -> ir::GlobalValue { + self.vmctx.unwrap_or_else(|| { + let vmctx = func.create_global_value(ir::GlobalValueData::VMContext); + self.vmctx = Some(vmctx); + vmctx + }) + } + + fn get_memory_grow_sig(&mut self, func: &mut Function) -> ir::SigRef { + let sig = self.memory_grow_sig.unwrap_or_else(|| { + func.import_signature(Signature { + params: vec![ + AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext), + AbiParam::new(I32), + AbiParam::new(I32), + ], + returns: vec![AbiParam::new(I32)], + call_conv: self.target_config.default_call_conv, + }) + }); + self.memory_grow_sig = Some(sig); + sig + } + + /// Return the memory.grow function signature to call for the given index, along with the + /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`. + fn get_memory_grow_func( + &mut self, + func: &mut Function, + index: MemoryIndex, + ) -> (ir::SigRef, usize, BuiltinFunctionIndex) { + if self.module.is_imported_memory(index) { + ( + self.get_memory_grow_sig(func), + index.index(), + BuiltinFunctionIndex::get_imported_memory32_grow_index(), + ) + } else { + ( + self.get_memory_grow_sig(func), + self.module.defined_memory_index(index).unwrap().index(), + BuiltinFunctionIndex::get_memory32_grow_index(), + ) + } + } + + fn get_memory32_size_sig(&mut self, func: &mut Function) -> ir::SigRef { + let sig = self.memory32_size_sig.unwrap_or_else(|| { + func.import_signature(Signature { + params: vec![ + AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext), + AbiParam::new(I32), + ], + returns: vec![AbiParam::new(I32)], + call_conv: self.target_config.default_call_conv, + }) + }); + self.memory32_size_sig = Some(sig); + sig + } + + /// Return the memory.size function signature to call for the given index, along with the + /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`. + fn get_memory_size_func( + &mut self, + func: &mut Function, + index: MemoryIndex, + ) -> (ir::SigRef, usize, BuiltinFunctionIndex) { + if self.module.is_imported_memory(index) { + ( + self.get_memory32_size_sig(func), + index.index(), + BuiltinFunctionIndex::get_imported_memory32_size_index(), + ) + } else { + ( + self.get_memory32_size_sig(func), + self.module.defined_memory_index(index).unwrap().index(), + BuiltinFunctionIndex::get_memory32_size_index(), + ) + } + } + + /// Translates load of builtin function and returns a pair of values `vmctx` + /// and address of the loaded function. + fn translate_load_builtin_function_address( + &mut self, + pos: &mut FuncCursor<'_>, + callee_func_idx: BuiltinFunctionIndex, + ) -> (ir::Value, ir::Value) { + // We use an indirect call so that we don't have to patch the code at runtime. + let pointer_type = self.pointer_type(); + let vmctx = self.vmctx(&mut pos.func); + let base = pos.ins().global_value(pointer_type, vmctx); + + let mut mem_flags = ir::MemFlags::trusted(); + mem_flags.set_readonly(); + + // Load the callee address. + let body_offset = + i32::try_from(self.offsets.vmctx_builtin_function(callee_func_idx)).unwrap(); + let func_addr = pos.ins().load(pointer_type, mem_flags, base, body_offset); + + (base, func_addr) + } +} + +#[cfg(feature = "lightbeam")] +impl lightbeam::ModuleContext for FuncEnvironment<'_> { + type Signature = ir::Signature; + type GlobalType = ir::Type; + + fn func_index(&self, defined_func_index: u32) -> u32 { + self.module + .func_index(DefinedFuncIndex::from_u32(defined_func_index)) + .as_u32() + } + + fn defined_func_index(&self, func_index: u32) -> Option<u32> { + self.module + .defined_func_index(FuncIndex::from_u32(func_index)) + .map(DefinedFuncIndex::as_u32) + } + + fn defined_global_index(&self, global_index: u32) -> Option<u32> { + self.module + .defined_global_index(GlobalIndex::from_u32(global_index)) + .map(DefinedGlobalIndex::as_u32) + } + + fn global_type(&self, global_index: u32) -> &Self::GlobalType { + &self.module.globals[GlobalIndex::from_u32(global_index)].ty + } + + fn func_type_index(&self, func_idx: u32) -> u32 { + self.module.functions[FuncIndex::from_u32(func_idx)].as_u32() + } + + fn signature(&self, index: u32) -> &Self::Signature { + &self.module.signatures[SignatureIndex::from_u32(index)] + } + + fn defined_table_index(&self, table_index: u32) -> Option<u32> { + self.module + .defined_table_index(TableIndex::from_u32(table_index)) + .map(DefinedTableIndex::as_u32) + } + + fn defined_memory_index(&self, memory_index: u32) -> Option<u32> { + self.module + .defined_memory_index(MemoryIndex::from_u32(memory_index)) + .map(DefinedMemoryIndex::as_u32) + } + + fn vmctx_vmfunction_import_body(&self, func_index: u32) -> u32 { + self.offsets + .vmctx_vmfunction_import_body(FuncIndex::from_u32(func_index)) + } + fn vmctx_vmfunction_import_vmctx(&self, func_index: u32) -> u32 { + self.offsets + .vmctx_vmfunction_import_vmctx(FuncIndex::from_u32(func_index)) + } + + fn vmctx_vmglobal_import_from(&self, global_index: u32) -> u32 { + self.offsets + .vmctx_vmglobal_import_from(GlobalIndex::from_u32(global_index)) + } + fn vmctx_vmglobal_definition(&self, defined_global_index: u32) -> u32 { + self.offsets + .vmctx_vmglobal_definition(DefinedGlobalIndex::from_u32(defined_global_index)) + } + fn vmctx_vmmemory_import_from(&self, memory_index: u32) -> u32 { + self.offsets + .vmctx_vmmemory_import_from(MemoryIndex::from_u32(memory_index)) + } + fn vmctx_vmmemory_definition(&self, defined_memory_index: u32) -> u32 { + self.offsets + .vmctx_vmmemory_definition(DefinedMemoryIndex::from_u32(defined_memory_index)) + } + fn vmctx_vmmemory_definition_base(&self, defined_memory_index: u32) -> u32 { + self.offsets + .vmctx_vmmemory_definition_base(DefinedMemoryIndex::from_u32(defined_memory_index)) + } + fn vmctx_vmmemory_definition_current_length(&self, defined_memory_index: u32) -> u32 { + self.offsets + .vmctx_vmmemory_definition_current_length(DefinedMemoryIndex::from_u32( + defined_memory_index, + )) + } + fn vmmemory_definition_base(&self) -> u8 { + self.offsets.vmmemory_definition_base() + } + fn vmmemory_definition_current_length(&self) -> u8 { + self.offsets.vmmemory_definition_current_length() + } + fn vmctx_vmtable_import_from(&self, table_index: u32) -> u32 { + self.offsets + .vmctx_vmtable_import_from(TableIndex::from_u32(table_index)) + } + fn vmctx_vmtable_definition(&self, defined_table_index: u32) -> u32 { + self.offsets + .vmctx_vmtable_definition(DefinedTableIndex::from_u32(defined_table_index)) + } + fn vmctx_vmtable_definition_base(&self, defined_table_index: u32) -> u32 { + self.offsets + .vmctx_vmtable_definition_base(DefinedTableIndex::from_u32(defined_table_index)) + } + fn vmctx_vmtable_definition_current_elements(&self, defined_table_index: u32) -> u32 { + self.offsets + .vmctx_vmtable_definition_current_elements(DefinedTableIndex::from_u32( + defined_table_index, + )) + } + fn vmtable_definition_base(&self) -> u8 { + self.offsets.vmtable_definition_base() + } + fn vmtable_definition_current_elements(&self) -> u8 { + self.offsets.vmtable_definition_current_elements() + } + fn vmcaller_checked_anyfunc_type_index(&self) -> u8 { + self.offsets.vmcaller_checked_anyfunc_type_index() + } + fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8 { + self.offsets.vmcaller_checked_anyfunc_func_ptr() + } + fn vmcaller_checked_anyfunc_vmctx(&self) -> u8 { + self.offsets.vmcaller_checked_anyfunc_vmctx() + } + fn size_of_vmcaller_checked_anyfunc(&self) -> u8 { + self.offsets.size_of_vmcaller_checked_anyfunc() + } + fn vmctx_vmshared_signature_id(&self, signature_idx: u32) -> u32 { + self.offsets + .vmctx_vmshared_signature_id(SignatureIndex::from_u32(signature_idx)) + } + + // TODO: type of a global +} + +impl<'module_environment> TargetEnvironment for FuncEnvironment<'module_environment> { + fn target_config(&self) -> TargetFrontendConfig { + self.target_config + } +} + +impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'module_environment> { + fn is_wasm_parameter(&self, _signature: &ir::Signature, index: usize) -> bool { + // The first two parameters are the vmctx and caller vmctx. The rest are + // the wasm parameters. + index >= 2 + } + + fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table> { + let pointer_type = self.pointer_type(); + + let (ptr, base_offset, current_elements_offset) = { + let vmctx = self.vmctx(func); + if let Some(def_index) = self.module.defined_table_index(index) { + let base_offset = + i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap(); + let current_elements_offset = i32::try_from( + self.offsets + .vmctx_vmtable_definition_current_elements(def_index), + ) + .unwrap(); + (vmctx, base_offset, current_elements_offset) + } else { + let from_offset = self.offsets.vmctx_vmtable_import_from(index); + let table = func.create_global_value(ir::GlobalValueData::Load { + base: vmctx, + offset: Offset32::new(i32::try_from(from_offset).unwrap()), + global_type: pointer_type, + readonly: true, + }); + let base_offset = i32::from(self.offsets.vmtable_definition_base()); + let current_elements_offset = + i32::from(self.offsets.vmtable_definition_current_elements()); + (table, base_offset, current_elements_offset) + } + }; + + let base_gv = func.create_global_value(ir::GlobalValueData::Load { + base: ptr, + offset: Offset32::new(base_offset), + global_type: pointer_type, + readonly: false, + }); + let bound_gv = func.create_global_value(ir::GlobalValueData::Load { + base: ptr, + offset: Offset32::new(current_elements_offset), + global_type: self.offsets.type_of_vmtable_definition_current_elements(), + readonly: false, + }); + + let element_size = match self.module.table_plans[index].style { + TableStyle::CallerChecksSignature => { + u64::from(self.offsets.size_of_vmcaller_checked_anyfunc()) + } + }; + + Ok(func.create_table(ir::TableData { + base_gv, + min_size: Uimm64::new(0), + bound_gv, + element_size: Uimm64::new(element_size), + index_type: I32, + })) + } + + fn translate_table_grow( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: u32, + _: ir::Value, + _: ir::Value, + ) -> WasmResult<ir::Value> { + Err(WasmError::Unsupported( + "the `table.grow` instruction is not supported yet".into(), + )) + } + + fn translate_table_get( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: u32, + _: ir::Value, + ) -> WasmResult<ir::Value> { + Err(WasmError::Unsupported( + "the `table.get` instruction is not supported yet".into(), + )) + } + + fn translate_table_set( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: u32, + _: ir::Value, + _: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported( + "the `table.set` instruction is not supported yet".into(), + )) + } + + fn translate_table_fill( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: u32, + _: ir::Value, + _: ir::Value, + _: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported( + "the `table.fill` instruction is not supported yet".into(), + )) + } + + fn translate_ref_func( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: u32, + ) -> WasmResult<ir::Value> { + Err(WasmError::Unsupported( + "the `ref.func` instruction is not supported yet".into(), + )) + } + + fn translate_custom_global_get( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: cranelift_wasm::GlobalIndex, + ) -> WasmResult<ir::Value> { + unreachable!("we don't make any custom globals") + } + + fn translate_custom_global_set( + &mut self, + _: cranelift_codegen::cursor::FuncCursor<'_>, + _: cranelift_wasm::GlobalIndex, + _: ir::Value, + ) -> WasmResult<()> { + unreachable!("we don't make any custom globals") + } + + fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<ir::Heap> { + let pointer_type = self.pointer_type(); + + let (ptr, base_offset, current_length_offset) = { + let vmctx = self.vmctx(func); + if let Some(def_index) = self.module.defined_memory_index(index) { + let base_offset = + i32::try_from(self.offsets.vmctx_vmmemory_definition_base(def_index)).unwrap(); + let current_length_offset = i32::try_from( + self.offsets + .vmctx_vmmemory_definition_current_length(def_index), + ) + .unwrap(); + (vmctx, base_offset, current_length_offset) + } else { + let from_offset = self.offsets.vmctx_vmmemory_import_from(index); + let memory = func.create_global_value(ir::GlobalValueData::Load { + base: vmctx, + offset: Offset32::new(i32::try_from(from_offset).unwrap()), + global_type: pointer_type, + readonly: true, + }); + let base_offset = i32::from(self.offsets.vmmemory_definition_base()); + let current_length_offset = + i32::from(self.offsets.vmmemory_definition_current_length()); + (memory, base_offset, current_length_offset) + } + }; + + // If we have a declared maximum, we can make this a "static" heap, which is + // allocated up front and never moved. + let (offset_guard_size, heap_style, readonly_base) = match self.module.memory_plans[index] { + MemoryPlan { + style: MemoryStyle::Dynamic, + offset_guard_size, + memory: _, + } => { + let heap_bound = func.create_global_value(ir::GlobalValueData::Load { + base: ptr, + offset: Offset32::new(current_length_offset), + global_type: self.offsets.type_of_vmmemory_definition_current_length(), + readonly: false, + }); + ( + Uimm64::new(offset_guard_size), + ir::HeapStyle::Dynamic { + bound_gv: heap_bound, + }, + false, + ) + } + MemoryPlan { + style: MemoryStyle::Static { bound }, + offset_guard_size, + memory: _, + } => ( + Uimm64::new(offset_guard_size), + ir::HeapStyle::Static { + bound: Uimm64::new(u64::from(bound) * u64::from(WASM_PAGE_SIZE)), + }, + true, + ), + }; + + let heap_base = func.create_global_value(ir::GlobalValueData::Load { + base: ptr, + offset: Offset32::new(base_offset), + global_type: pointer_type, + readonly: readonly_base, + }); + Ok(func.create_heap(ir::HeapData { + base: heap_base, + min_size: 0.into(), + offset_guard_size, + style: heap_style, + index_type: I32, + })) + } + + fn make_global( + &mut self, + func: &mut ir::Function, + index: GlobalIndex, + ) -> WasmResult<GlobalVariable> { + let pointer_type = self.pointer_type(); + + let (ptr, offset) = { + let vmctx = self.vmctx(func); + if let Some(def_index) = self.module.defined_global_index(index) { + let offset = + i32::try_from(self.offsets.vmctx_vmglobal_definition(def_index)).unwrap(); + (vmctx, offset) + } else { + let from_offset = self.offsets.vmctx_vmglobal_import_from(index); + let global = func.create_global_value(ir::GlobalValueData::Load { + base: vmctx, + offset: Offset32::new(i32::try_from(from_offset).unwrap()), + global_type: pointer_type, + readonly: true, + }); + (global, 0) + } + }; + + Ok(GlobalVariable::Memory { + gv: ptr, + offset: offset.into(), + ty: self.module.globals[index].ty, + }) + } + + fn make_indirect_sig( + &mut self, + func: &mut ir::Function, + index: SignatureIndex, + ) -> WasmResult<ir::SigRef> { + Ok(func.import_signature(self.module.signatures[index].clone())) + } + + fn make_direct_func( + &mut self, + func: &mut ir::Function, + index: FuncIndex, + ) -> WasmResult<ir::FuncRef> { + let sigidx = self.module.functions[index]; + let signature = func.import_signature(self.module.signatures[sigidx].clone()); + let name = get_func_name(index); + Ok(func.import_function(ir::ExtFuncData { + name, + signature, + // We currently allocate all code segments independently, so nothing + // is colocated. + colocated: false, + })) + } + + fn translate_call_indirect( + &mut self, + mut pos: FuncCursor<'_>, + table_index: TableIndex, + table: ir::Table, + sig_index: SignatureIndex, + sig_ref: ir::SigRef, + callee: ir::Value, + call_args: &[ir::Value], + ) -> WasmResult<ir::Inst> { + let pointer_type = self.pointer_type(); + + let table_entry_addr = pos.ins().table_addr(pointer_type, table, callee, 0); + + // Dereference table_entry_addr to get the function address. + let mem_flags = ir::MemFlags::trusted(); + let func_addr = pos.ins().load( + pointer_type, + mem_flags, + table_entry_addr, + i32::from(self.offsets.vmcaller_checked_anyfunc_func_ptr()), + ); + + // Check whether `func_addr` is null. + pos.ins().trapz(func_addr, ir::TrapCode::IndirectCallToNull); + + // If necessary, check the signature. + match self.module.table_plans[table_index].style { + TableStyle::CallerChecksSignature => { + let sig_id_size = self.offsets.size_of_vmshared_signature_index(); + let sig_id_type = Type::int(u16::from(sig_id_size) * 8).unwrap(); + let vmctx = self.vmctx(pos.func); + let base = pos.ins().global_value(pointer_type, vmctx); + let offset = + i32::try_from(self.offsets.vmctx_vmshared_signature_id(sig_index)).unwrap(); + + // Load the caller ID. + let mut mem_flags = ir::MemFlags::trusted(); + mem_flags.set_readonly(); + let caller_sig_id = pos.ins().load(sig_id_type, mem_flags, base, offset); + + // Load the callee ID. + let mem_flags = ir::MemFlags::trusted(); + let callee_sig_id = pos.ins().load( + sig_id_type, + mem_flags, + table_entry_addr, + i32::from(self.offsets.vmcaller_checked_anyfunc_type_index()), + ); + + // Check that they match. + let cmp = pos.ins().icmp(IntCC::Equal, callee_sig_id, caller_sig_id); + pos.ins().trapz(cmp, ir::TrapCode::BadSignature); + } + } + + let mut real_call_args = Vec::with_capacity(call_args.len() + 2); + let caller_vmctx = pos.func.special_param(ArgumentPurpose::VMContext).unwrap(); + + // First append the callee vmctx address. + let vmctx = pos.ins().load( + pointer_type, + mem_flags, + table_entry_addr, + i32::from(self.offsets.vmcaller_checked_anyfunc_vmctx()), + ); + real_call_args.push(vmctx); + real_call_args.push(caller_vmctx); + + // Then append the regular call arguments. + real_call_args.extend_from_slice(call_args); + + Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args)) + } + + fn translate_call( + &mut self, + mut pos: FuncCursor<'_>, + callee_index: FuncIndex, + callee: ir::FuncRef, + call_args: &[ir::Value], + ) -> WasmResult<ir::Inst> { + let mut real_call_args = Vec::with_capacity(call_args.len() + 2); + let caller_vmctx = pos.func.special_param(ArgumentPurpose::VMContext).unwrap(); + + // Handle direct calls to locally-defined functions. + if !self.module.is_imported_function(callee_index) { + // First append the callee vmctx address, which is the same as the caller vmctx in + // this case. + real_call_args.push(caller_vmctx); + + // Then append the caller vmctx address. + real_call_args.push(caller_vmctx); + + // Then append the regular call arguments. + real_call_args.extend_from_slice(call_args); + + return Ok(pos.ins().call(callee, &real_call_args)); + } + + // Handle direct calls to imported functions. We use an indirect call + // so that we don't have to patch the code at runtime. + let pointer_type = self.pointer_type(); + let sig_ref = pos.func.dfg.ext_funcs[callee].signature; + let vmctx = self.vmctx(&mut pos.func); + let base = pos.ins().global_value(pointer_type, vmctx); + + let mem_flags = ir::MemFlags::trusted(); + + // Load the callee address. + let body_offset = + i32::try_from(self.offsets.vmctx_vmfunction_import_body(callee_index)).unwrap(); + let func_addr = pos.ins().load(pointer_type, mem_flags, base, body_offset); + + // First append the callee vmctx address. + let vmctx_offset = + i32::try_from(self.offsets.vmctx_vmfunction_import_vmctx(callee_index)).unwrap(); + let vmctx = pos.ins().load(pointer_type, mem_flags, base, vmctx_offset); + real_call_args.push(vmctx); + real_call_args.push(caller_vmctx); + + // Then append the regular call arguments. + real_call_args.extend_from_slice(call_args); + + Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args)) + } + + fn translate_memory_grow( + &mut self, + mut pos: FuncCursor<'_>, + index: MemoryIndex, + _heap: ir::Heap, + val: ir::Value, + ) -> WasmResult<ir::Value> { + let (func_sig, index_arg, func_idx) = self.get_memory_grow_func(&mut pos.func, index); + let memory_index = pos.ins().iconst(I32, index_arg as i64); + let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx); + let call_inst = pos + .ins() + .call_indirect(func_sig, func_addr, &[vmctx, val, memory_index]); + Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap()) + } + + fn translate_memory_size( + &mut self, + mut pos: FuncCursor<'_>, + index: MemoryIndex, + _heap: ir::Heap, + ) -> WasmResult<ir::Value> { + let (func_sig, index_arg, func_idx) = self.get_memory_size_func(&mut pos.func, index); + let memory_index = pos.ins().iconst(I32, index_arg as i64); + let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx); + let call_inst = pos + .ins() + .call_indirect(func_sig, func_addr, &[vmctx, memory_index]); + Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap()) + } + + fn translate_memory_copy( + &mut self, + _pos: FuncCursor, + _index: MemoryIndex, + _heap: ir::Heap, + _dst: ir::Value, + _src: ir::Value, + _len: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_memory_fill( + &mut self, + _pos: FuncCursor, + _index: MemoryIndex, + _heap: ir::Heap, + _dst: ir::Value, + _val: ir::Value, + _len: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_memory_init( + &mut self, + _pos: FuncCursor, + _index: MemoryIndex, + _heap: ir::Heap, + _seg_index: u32, + _dst: ir::Value, + _src: ir::Value, + _len: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_data_drop(&mut self, _pos: FuncCursor, _seg_index: u32) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_table_size( + &mut self, + _pos: FuncCursor, + _index: TableIndex, + _table: ir::Table, + ) -> WasmResult<ir::Value> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_table_copy( + &mut self, + _pos: FuncCursor, + _dst_table_index: TableIndex, + _dst_table: ir::Table, + _src_table_index: TableIndex, + _src_table: ir::Table, + _dst: ir::Value, + _src: ir::Value, + _len: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_table_init( + &mut self, + _pos: FuncCursor, + _seg_index: u32, + _table_index: TableIndex, + _table: ir::Table, + _dst: ir::Value, + _src: ir::Value, + _len: ir::Value, + ) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } + + fn translate_elem_drop(&mut self, _pos: FuncCursor, _seg_index: u32) -> WasmResult<()> { + Err(WasmError::Unsupported("bulk memory".to_string())) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +
+//! Standalone environment for WebAssembly using Cranelift. Provides functions to translate +//! `get_global`, `set_global`, `memory.size`, `memory.grow`, `call_indirect` that hardcode in +//! the translation the base addresses of regions of memory that will hold the globals, tables and +//! linear memories. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod address_map; +mod compilation; +mod data_structures; +mod func_environ; +mod module; +mod module_environ; +mod tunables; +mod vmoffsets; + +mod cache; + +pub mod cranelift; +#[cfg(feature = "lightbeam")] +pub mod lightbeam; + +pub use crate::address_map::{ + FunctionAddressMap, InstructionAddressMap, ModuleAddressMap, ModuleMemoryOffset, + ModuleVmctxInfo, ValueLabelsRanges, +}; +pub use crate::cache::create_new_config as cache_create_new_config; +pub use crate::cache::CacheConfig; +pub use crate::compilation::{ + Compilation, CompileError, CompiledFunction, CompiledFunctionUnwindInfo, + CompiledFunctionUnwindInfoReloc, Compiler, Relocation, RelocationTarget, Relocations, + TrapInformation, Traps, +}; +pub use crate::cranelift::Cranelift; +pub use crate::data_structures::*; +pub use crate::func_environ::BuiltinFunctionIndex; +#[cfg(feature = "lightbeam")] +pub use crate::lightbeam::Lightbeam; +pub use crate::module::{ + Export, MemoryPlan, MemoryStyle, Module, TableElements, TablePlan, TableStyle, +}; +pub use crate::module_environ::{ + translate_signature, DataInitializer, DataInitializerLocation, FunctionBodyData, + ModuleEnvironment, ModuleTranslation, +}; +pub use crate::tunables::Tunables; +pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMOffsets}; + +/// WebAssembly page sizes are defined to be 64KiB. +pub const WASM_PAGE_SIZE: u32 = 0x10000; + +/// The number of pages we can have before we run out of byte index space. +pub const WASM_MAX_PAGES: u32 = 0x10000; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +
+//! Data structures for representing decoded wasm modules. + +use crate::module_environ::FunctionBodyData; +use crate::tunables::Tunables; +use crate::WASM_MAX_PAGES; +use cranelift_codegen::ir; +use cranelift_entity::{EntityRef, PrimaryMap}; +use cranelift_wasm::{ + DefinedFuncIndex, DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, FuncIndex, Global, + GlobalIndex, Memory, MemoryIndex, SignatureIndex, Table, TableIndex, +}; +use indexmap::IndexMap; +use more_asserts::assert_ge; +use std::collections::HashMap; +use std::hash::{Hash, Hasher}; +use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; + +/// A WebAssembly table initializer. +#[derive(Clone, Debug, Hash)] +pub struct TableElements { + /// The index of a table to initialize. + pub table_index: TableIndex, + /// Optionally, a global variable giving a base index. + pub base: Option<GlobalIndex>, + /// The offset to add to the base. + pub offset: usize, + /// The values to write into the table elements. + pub elements: Box<[FuncIndex]>, +} + +/// An entity to export. +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub enum Export { + /// Function export. + Function(FuncIndex), + /// Table export. + Table(TableIndex), + /// Memory export. + Memory(MemoryIndex), + /// Global export. + Global(GlobalIndex), +} + +/// Implemenation styles for WebAssembly linear memory. +#[derive(Debug, Clone, Hash)] +pub enum MemoryStyle { + /// The actual memory can be resized and moved. + Dynamic, + /// Addresss space is allocated up front. + Static { + /// The number of mapped and unmapped pages. + bound: u32, + }, +} + +impl MemoryStyle { + /// Decide on an implementation style for the given `Memory`. + pub fn for_memory(memory: Memory, tunables: &Tunables) -> (Self, u64) { + // A heap with a maximum that doesn't exceed the static memory bound specified by the + // tunables make it static. + // + // If the module doesn't declare an explicit maximum treat it as 4GiB. + let maximum = memory.maximum.unwrap_or(WASM_MAX_PAGES); + if maximum <= tunables.static_memory_bound { + assert_ge!(tunables.static_memory_bound, memory.minimum); + return ( + Self::Static { + bound: tunables.static_memory_bound, + }, + tunables.static_memory_offset_guard_size, + ); + } + + // Otherwise, make it dynamic. + (Self::Dynamic, tunables.dynamic_memory_offset_guard_size) + } +} + +/// A WebAssembly linear memory description along with our chosen style for +/// implementing it. +#[derive(Debug, Clone, Hash)] +pub struct MemoryPlan { + /// The WebAssembly linear memory description. + pub memory: Memory, + /// Our chosen implementation style. + pub style: MemoryStyle, + /// Our chosen offset-guard size. + pub offset_guard_size: u64, +} + +impl MemoryPlan { + /// Draw up a plan for implementing a `Memory`. + pub fn for_memory(memory: Memory, tunables: &Tunables) -> Self { + let (style, offset_guard_size) = MemoryStyle::for_memory(memory, tunables); + Self { + memory, + style, + offset_guard_size, + } + } +} + +/// Implemenation styles for WebAssembly tables. +#[derive(Debug, Clone, Hash)] +pub enum TableStyle { + /// Signatures are stored in the table and checked in the caller. + CallerChecksSignature, +} + +impl TableStyle { + /// Decide on an implementation style for the given `Table`. + pub fn for_table(_table: Table, _tunables: &Tunables) -> Self { + Self::CallerChecksSignature + } +} + +/// A WebAssembly table description along with our chosen style for +/// implementing it. +#[derive(Debug, Clone, Hash)] +pub struct TablePlan { + /// The WebAssembly table description. + pub table: cranelift_wasm::Table, + /// Our chosen implementation style. + pub style: TableStyle, +} + +impl TablePlan { + /// Draw up a plan for implementing a `Table`. + pub fn for_table(table: Table, tunables: &Tunables) -> Self { + let style = TableStyle::for_table(table, tunables); + Self { table, style } + } +} + +/// A translated WebAssembly module, excluding the function bodies and +/// memory initializers. +// WARNING: when modifying, make sure that `hash_for_cache` is still valid! +#[derive(Debug)] +pub struct Module { + /// A unique identifier (within this process) for this module. + pub id: usize, + + /// Unprocessed signatures exactly as provided by `declare_signature()`. + pub signatures: PrimaryMap<SignatureIndex, ir::Signature>, + + /// Names of imported functions, as well as the index of the import that + /// performed this import. + pub imported_funcs: PrimaryMap<FuncIndex, (String, String, u32)>, + + /// Names of imported tables. + pub imported_tables: PrimaryMap<TableIndex, (String, String, u32)>, + + /// Names of imported memories. + pub imported_memories: PrimaryMap<MemoryIndex, (String, String, u32)>, + + /// Names of imported globals. + pub imported_globals: PrimaryMap<GlobalIndex, (String, String, u32)>, + + /// Types of functions, imported and local. + pub functions: PrimaryMap<FuncIndex, SignatureIndex>, + + /// WebAssembly tables. + pub table_plans: PrimaryMap<TableIndex, TablePlan>, + + /// WebAssembly linear memory plans. + pub memory_plans: PrimaryMap<MemoryIndex, MemoryPlan>, + + /// WebAssembly global variables. + pub globals: PrimaryMap<GlobalIndex, Global>, + + /// Exported entities. + pub exports: IndexMap<String, Export>, + + /// The module "start" function, if present. + pub start_func: Option<FuncIndex>, + + /// WebAssembly table initializers. + pub table_elements: Vec<TableElements>, + + /// WebAssembly table initializers. + pub func_names: HashMap<FuncIndex, String>, +} + +impl Module { + /// Allocates the module data structures. + pub fn new() -> Self { + static NEXT_ID: AtomicUsize = AtomicUsize::new(0); + + Self { + id: NEXT_ID.fetch_add(1, SeqCst), + signatures: PrimaryMap::new(), + imported_funcs: PrimaryMap::new(), + imported_tables: PrimaryMap::new(), + imported_memories: PrimaryMap::new(), + imported_globals: PrimaryMap::new(), + functions: PrimaryMap::new(), + table_plans: PrimaryMap::new(), + memory_plans: PrimaryMap::new(), + globals: PrimaryMap::new(), + exports: IndexMap::new(), + start_func: None, + table_elements: Vec::new(), + func_names: HashMap::new(), + } + } + + /// Convert a `DefinedFuncIndex` into a `FuncIndex`. + pub fn func_index(&self, defined_func: DefinedFuncIndex) -> FuncIndex { + FuncIndex::new(self.imported_funcs.len() + defined_func.index()) + } + + /// Convert a `FuncIndex` into a `DefinedFuncIndex`. Returns None if the + /// index is an imported function. + pub fn defined_func_index(&self, func: FuncIndex) -> Option<DefinedFuncIndex> { + if func.index() < self.imported_funcs.len() { + None + } else { + Some(DefinedFuncIndex::new( + func.index() - self.imported_funcs.len(), + )) + } + } + + /// Test whether the given function index is for an imported function. + pub fn is_imported_function(&self, index: FuncIndex) -> bool { + index.index() < self.imported_funcs.len() + } + + /// Convert a `DefinedTableIndex` into a `TableIndex`. + pub fn table_index(&self, defined_table: DefinedTableIndex) -> TableIndex { + TableIndex::new(self.imported_tables.len() + defined_table.index()) + } + + /// Convert a `TableIndex` into a `DefinedTableIndex`. Returns None if the + /// index is an imported table. + pub fn defined_table_index(&self, table: TableIndex) -> Option<DefinedTableIndex> { + if table.index() < self.imported_tables.len() { + None + } else { + Some(DefinedTableIndex::new( + table.index() - self.imported_tables.len(), + )) + } + } + + /// Test whether the given table index is for an imported table. + pub fn is_imported_table(&self, index: TableIndex) -> bool { + index.index() < self.imported_tables.len() + } + + /// Convert a `DefinedMemoryIndex` into a `MemoryIndex`. + pub fn memory_index(&self, defined_memory: DefinedMemoryIndex) -> MemoryIndex { + MemoryIndex::new(self.imported_memories.len() + defined_memory.index()) + } + + /// Convert a `MemoryIndex` into a `DefinedMemoryIndex`. Returns None if the + /// index is an imported memory. + pub fn defined_memory_index(&self, memory: MemoryIndex) -> Option<DefinedMemoryIndex> { + if memory.index() < self.imported_memories.len() { + None + } else { + Some(DefinedMemoryIndex::new( + memory.index() - self.imported_memories.len(), + )) + } + } + + /// Test whether the given memory index is for an imported memory. + pub fn is_imported_memory(&self, index: MemoryIndex) -> bool { + index.index() < self.imported_memories.len() + } + + /// Convert a `DefinedGlobalIndex` into a `GlobalIndex`. + pub fn global_index(&self, defined_global: DefinedGlobalIndex) -> GlobalIndex { + GlobalIndex::new(self.imported_globals.len() + defined_global.index()) + } + + /// Convert a `GlobalIndex` into a `DefinedGlobalIndex`. Returns None if the + /// index is an imported global. + pub fn defined_global_index(&self, global: GlobalIndex) -> Option<DefinedGlobalIndex> { + if global.index() < self.imported_globals.len() { + None + } else { + Some(DefinedGlobalIndex::new( + global.index() - self.imported_globals.len(), + )) + } + } + + /// Test whether the given global index is for an imported global. + pub fn is_imported_global(&self, index: GlobalIndex) -> bool { + index.index() < self.imported_globals.len() + } + + /// Computes hash of the module for the purpose of caching. + pub fn hash_for_cache<'data, H>( + &self, + function_body_inputs: &PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + state: &mut H, + ) where + H: Hasher, + { + // There's no need to cache names (strings), start function + // and data initializers (for both memory and tables) + self.signatures.hash(state); + self.functions.hash(state); + self.table_plans.hash(state); + self.memory_plans.hash(state); + self.globals.hash(state); + // IndexMap (self.export) iterates over values in order of item inserts + // Let's actually sort the values. + let mut exports = self.exports.values().collect::<Vec<_>>(); + exports.sort(); + for val in exports { + val.hash(state); + } + function_body_inputs.hash(state); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +
+use crate::func_environ::FuncEnvironment; +use crate::module::{Export, MemoryPlan, Module, TableElements, TablePlan}; +use crate::tunables::Tunables; +use cranelift_codegen::ir; +use cranelift_codegen::ir::{AbiParam, ArgumentPurpose}; +use cranelift_codegen::isa::TargetFrontendConfig; +use cranelift_entity::PrimaryMap; +use cranelift_wasm::{ + self, translate_module, DefinedFuncIndex, FuncIndex, Global, GlobalIndex, Memory, MemoryIndex, + ModuleTranslationState, SignatureIndex, Table, TableIndex, TargetEnvironment, WasmResult, +}; +use std::convert::TryFrom; + +/// Contains function data: byte code and its offset in the module. +#[derive(Hash)] +pub struct FunctionBodyData<'a> { + /// Body byte code. + pub data: &'a [u8], + + /// Body offset in the module file. + pub module_offset: usize, +} + +/// The result of translating via `ModuleEnvironment`. Function bodies are not +/// yet translated, and data initializers have not yet been copied out of the +/// original buffer. +pub struct ModuleTranslation<'data> { + /// Compilation setting flags. + pub target_config: TargetFrontendConfig, + + /// Module information. + pub module: Module, + + /// References to the function bodies. + pub function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + + /// References to the data initializers. + pub data_initializers: Vec<DataInitializer<'data>>, + + /// Tunable parameters. + pub tunables: Tunables, + + /// The decoded Wasm types for the module. + pub module_translation: Option<ModuleTranslationState>, +} + +impl<'data> ModuleTranslation<'data> { + /// Return a new `FuncEnvironment` for translating a function. + pub fn func_env(&self) -> FuncEnvironment<'_> { + FuncEnvironment::new(self.target_config, &self.module) + } +} + +/// Object containing the standalone environment information. +pub struct ModuleEnvironment<'data> { + /// The result to be filled in. + result: ModuleTranslation<'data>, + imports: u32, +} + +impl<'data> ModuleEnvironment<'data> { + /// Allocates the environment data structures. + pub fn new(target_config: TargetFrontendConfig, tunables: Tunables) -> Self { + Self { + result: ModuleTranslation { + target_config, + module: Module::new(), + function_body_inputs: PrimaryMap::new(), + data_initializers: Vec::new(), + tunables, + module_translation: None, + }, + imports: 0, + } + } + + fn pointer_type(&self) -> ir::Type { + self.result.target_config.pointer_type() + } + + /// Translate a wasm module using this environment. This consumes the + /// `ModuleEnvironment` and produces a `ModuleTranslation`. + pub fn translate(mut self, data: &'data [u8]) -> WasmResult<ModuleTranslation<'data>> { + assert!(self.result.module_translation.is_none()); + let module_translation = translate_module(data, &mut self)?; + self.result.module_translation = Some(module_translation); + Ok(self.result) + } + + fn declare_export(&mut self, export: Export, name: &str) -> WasmResult<()> { + self.result + .module + .exports + .insert(String::from(name), export); + Ok(()) + } +} + +impl<'data> TargetEnvironment for ModuleEnvironment<'data> { + fn target_config(&self) -> TargetFrontendConfig { + self.result.target_config + } +} + +/// This trait is useful for `translate_module` because it tells how to translate +/// environment-dependent wasm instructions. These functions should not be called by the user. +impl<'data> cranelift_wasm::ModuleEnvironment<'data> for ModuleEnvironment<'data> { + fn reserve_signatures(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .signatures + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_signature(&mut self, sig: ir::Signature) -> WasmResult<()> { + let sig = translate_signature(sig, self.pointer_type()); + // TODO: Deduplicate signatures. + self.result.module.signatures.push(sig); + Ok(()) + } + + fn declare_func_import( + &mut self, + sig_index: SignatureIndex, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.result.module.functions.len(), + self.result.module.imported_funcs.len(), + "Imported functions must be declared first" + ); + self.result.module.functions.push(sig_index); + + self.result.module.imported_funcs.push(( + String::from(module), + String::from(field), + self.imports, + )); + self.imports += 1; + Ok(()) + } + + fn declare_table_import(&mut self, table: Table, module: &str, field: &str) -> WasmResult<()> { + debug_assert_eq!( + self.result.module.table_plans.len(), + self.result.module.imported_tables.len(), + "Imported tables must be declared first" + ); + let plan = TablePlan::for_table(table, &self.result.tunables); + self.result.module.table_plans.push(plan); + + self.result.module.imported_tables.push(( + String::from(module), + String::from(field), + self.imports, + )); + self.imports += 1; + Ok(()) + } + + fn declare_memory_import( + &mut self, + memory: Memory, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.result.module.memory_plans.len(), + self.result.module.imported_memories.len(), + "Imported memories must be declared first" + ); + let plan = MemoryPlan::for_memory(memory, &self.result.tunables); + self.result.module.memory_plans.push(plan); + + self.result.module.imported_memories.push(( + String::from(module), + String::from(field), + self.imports, + )); + self.imports += 1; + Ok(()) + } + + fn declare_global_import( + &mut self, + global: Global, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.result.module.globals.len(), + self.result.module.imported_globals.len(), + "Imported globals must be declared first" + ); + self.result.module.globals.push(global); + + self.result.module.imported_globals.push(( + String::from(module), + String::from(field), + self.imports, + )); + self.imports += 1; + Ok(()) + } + + fn finish_imports(&mut self) -> WasmResult<()> { + self.result.module.imported_funcs.shrink_to_fit(); + self.result.module.imported_tables.shrink_to_fit(); + self.result.module.imported_memories.shrink_to_fit(); + self.result.module.imported_globals.shrink_to_fit(); + Ok(()) + } + + fn reserve_func_types(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .functions + .reserve_exact(usize::try_from(num).unwrap()); + self.result + .function_body_inputs + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()> { + self.result.module.functions.push(sig_index); + Ok(()) + } + + fn reserve_tables(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .table_plans + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_table(&mut self, table: Table) -> WasmResult<()> { + let plan = TablePlan::for_table(table, &self.result.tunables); + self.result.module.table_plans.push(plan); + Ok(()) + } + + fn reserve_memories(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .memory_plans + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_memory(&mut self, memory: Memory) -> WasmResult<()> { + let plan = MemoryPlan::for_memory(memory, &self.result.tunables); + self.result.module.memory_plans.push(plan); + Ok(()) + } + + fn reserve_globals(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .globals + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_global(&mut self, global: Global) -> WasmResult<()> { + self.result.module.globals.push(global); + Ok(()) + } + + fn reserve_exports(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .exports + .reserve(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_func_export(&mut self, func_index: FuncIndex, name: &str) -> WasmResult<()> { + self.declare_export(Export::Function(func_index), name) + } + + fn declare_table_export(&mut self, table_index: TableIndex, name: &str) -> WasmResult<()> { + self.declare_export(Export::Table(table_index), name) + } + + fn declare_memory_export(&mut self, memory_index: MemoryIndex, name: &str) -> WasmResult<()> { + self.declare_export(Export::Memory(memory_index), name) + } + + fn declare_global_export(&mut self, global_index: GlobalIndex, name: &str) -> WasmResult<()> { + self.declare_export(Export::Global(global_index), name) + } + + fn declare_start_func(&mut self, func_index: FuncIndex) -> WasmResult<()> { + debug_assert!(self.result.module.start_func.is_none()); + self.result.module.start_func = Some(func_index); + Ok(()) + } + + fn reserve_table_elements(&mut self, num: u32) -> WasmResult<()> { + self.result + .module + .table_elements + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_table_elements( + &mut self, + table_index: TableIndex, + base: Option<GlobalIndex>, + offset: usize, + elements: Box<[FuncIndex]>, + ) -> WasmResult<()> { + self.result.module.table_elements.push(TableElements { + table_index, + base, + offset, + elements, + }); + Ok(()) + } + + fn define_function_body( + &mut self, + _module_translation: &ModuleTranslationState, + body_bytes: &'data [u8], + body_offset: usize, + ) -> WasmResult<()> { + self.result.function_body_inputs.push(FunctionBodyData { + data: body_bytes, + module_offset: body_offset, + }); + Ok(()) + } + + fn reserve_data_initializers(&mut self, num: u32) -> WasmResult<()> { + self.result + .data_initializers + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + fn declare_data_initialization( + &mut self, + memory_index: MemoryIndex, + base: Option<GlobalIndex>, + offset: usize, + data: &'data [u8], + ) -> WasmResult<()> { + self.result.data_initializers.push(DataInitializer { + location: DataInitializerLocation { + memory_index, + base, + offset, + }, + data, + }); + Ok(()) + } + + fn declare_func_name(&mut self, func_index: FuncIndex, name: &'data str) -> WasmResult<()> { + self.result + .module + .func_names + .insert(func_index, name.to_string()); + Ok(()) + } +} + +/// Add environment-specific function parameters. +pub fn translate_signature(mut sig: ir::Signature, pointer_type: ir::Type) -> ir::Signature { + // Prepend the vmctx argument. + sig.params.insert( + 0, + AbiParam::special(pointer_type, ArgumentPurpose::VMContext), + ); + // Prepend the caller vmctx argument. + sig.params.insert(1, AbiParam::new(pointer_type)); + sig +} + +/// A memory index and offset within that memory where a data initialization +/// should is to be performed. +#[derive(Clone)] +pub struct DataInitializerLocation { + /// The index of the memory to initialize. + pub memory_index: MemoryIndex, + + /// Optionally a globalvar base to initialize at. + pub base: Option<GlobalIndex>, + + /// A constant offset to initialize at. + pub offset: usize, +} + +/// A data initializer for linear memory. +pub struct DataInitializer<'data> { + /// The location where the initialization is to be performed. + pub location: DataInitializerLocation, + + /// The initialization data. + pub data: &'data [u8], +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +
+/// Tunable parameters for WebAssembly compilation. +#[derive(Clone)] +pub struct Tunables { + /// For static heaps, the size in wasm pages of the heap protected by bounds checking. + pub static_memory_bound: u32, + + /// The size in bytes of the offset guard for static heaps. + pub static_memory_offset_guard_size: u64, + + /// The size in bytes of the offset guard for dynamic heaps. + pub dynamic_memory_offset_guard_size: u64, +} + +impl Default for Tunables { + fn default() -> Self { + Self { + #[cfg(target_pointer_width = "32")] + /// Size in wasm pages of the bound for static memories. + static_memory_bound: 0x4000, + #[cfg(target_pointer_width = "64")] + /// Size in wasm pages of the bound for static memories. + /// + /// When we allocate 4 GiB of address space, we can avoid the + /// need for explicit bounds checks. + static_memory_bound: 0x1_0000, + + #[cfg(target_pointer_width = "32")] + /// Size in bytes of the offset guard for static memories. + static_memory_offset_guard_size: 0x1_0000, + #[cfg(target_pointer_width = "64")] + /// Size in bytes of the offset guard for static memories. + /// + /// Allocating 2 GiB of address space lets us translate wasm + /// offsets into x86 offsets as aggressively as we can. + static_memory_offset_guard_size: 0x8000_0000, + + /// Size in bytes of the offset guard for dynamic memories. + /// + /// Allocate a small guard to optimize common cases but without + /// wasting too much memor. + dynamic_memory_offset_guard_size: 0x1_0000, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +
+//! Offsets and sizes of various structs in wasmtime-runtime's vmcontext +//! module. + +use crate::module::Module; +use crate::BuiltinFunctionIndex; +use cranelift_codegen::ir; +use cranelift_wasm::{ + DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, FuncIndex, GlobalIndex, MemoryIndex, + SignatureIndex, TableIndex, +}; +use more_asserts::assert_lt; +use std::convert::TryFrom; + +#[cfg(target_pointer_width = "32")] +fn cast_to_u32(sz: usize) -> u32 { + u32::try_from(sz).unwrap() +} +#[cfg(target_pointer_width = "64")] +fn cast_to_u32(sz: usize) -> u32 { + u32::try_from(sz).expect("overflow in cast from usize to u32") +} + +/// Align an offset used in this module to a specific byte-width by rounding up +fn align(offset: u32, width: u32) -> u32 { + (offset + (width - 1)) / width * width +} + +/// This class computes offsets to fields within `VMContext` and other +/// related structs that JIT code accesses directly. +pub struct VMOffsets { + /// The size in bytes of a pointer on the target. + pub pointer_size: u8, + /// The number of signature declarations in the module. + pub num_signature_ids: u32, + /// The number of imported functions in the module. + pub num_imported_functions: u32, + /// The number of imported tables in the module. + pub num_imported_tables: u32, + /// The number of imported memories in the module. + pub num_imported_memories: u32, + /// The number of imported globals in the module. + pub num_imported_globals: u32, + /// The number of defined tables in the module. + pub num_defined_tables: u32, + /// The number of defined memories in the module. + pub num_defined_memories: u32, + /// The number of defined globals in the module. + pub num_defined_globals: u32, +} + +impl VMOffsets { + /// Return a new `VMOffsets` instance, for a given pointer size. + pub fn new(pointer_size: u8, module: &Module) -> Self { + Self { + pointer_size, + num_signature_ids: cast_to_u32(module.signatures.len()), + num_imported_functions: cast_to_u32(module.imported_funcs.len()), + num_imported_tables: cast_to_u32(module.imported_tables.len()), + num_imported_memories: cast_to_u32(module.imported_memories.len()), + num_imported_globals: cast_to_u32(module.imported_globals.len()), + num_defined_tables: cast_to_u32(module.table_plans.len()), + num_defined_memories: cast_to_u32(module.memory_plans.len()), + num_defined_globals: cast_to_u32(module.globals.len()), + } + } +} + +/// Offsets for `VMFunctionImport`. +impl VMOffsets { + /// The offset of the `body` field. + #[allow(clippy::erasing_op)] + pub fn vmfunction_import_body(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `vmctx` field. + #[allow(clippy::identity_op)] + pub fn vmfunction_import_vmctx(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of `VMFunctionImport`. + pub fn size_of_vmfunction_import(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for `*const VMFunctionBody`. +impl VMOffsets { + /// The size of the `current_elements` field. + #[allow(clippy::identity_op)] + pub fn size_of_vmfunction_body_ptr(&self) -> u8 { + 1 * self.pointer_size + } +} + +/// Offsets for `VMTableImport`. +impl VMOffsets { + /// The offset of the `from` field. + #[allow(clippy::erasing_op)] + pub fn vmtable_import_from(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `vmctx` field. + #[allow(clippy::identity_op)] + pub fn vmtable_import_vmctx(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of `VMTableImport`. + pub fn size_of_vmtable_import(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for `VMTableDefinition`. +impl VMOffsets { + /// The offset of the `base` field. + #[allow(clippy::erasing_op)] + pub fn vmtable_definition_base(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `current_elements` field. + #[allow(clippy::identity_op)] + pub fn vmtable_definition_current_elements(&self) -> u8 { + 1 * self.pointer_size + } + + /// The size of the `current_elements` field. + pub fn size_of_vmtable_definition_current_elements(&self) -> u8 { + 4 + } + + /// Return the size of `VMTableDefinition`. + pub fn size_of_vmtable_definition(&self) -> u8 { + 2 * self.pointer_size + } + + /// The type of the `current_elements` field. + pub fn type_of_vmtable_definition_current_elements(&self) -> ir::Type { + ir::Type::int(u16::from(self.size_of_vmtable_definition_current_elements()) * 8).unwrap() + } +} + +/// Offsets for `VMMemoryImport`. +impl VMOffsets { + /// The offset of the `from` field. + #[allow(clippy::erasing_op)] + pub fn vmmemory_import_from(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `vmctx` field. + #[allow(clippy::identity_op)] + pub fn vmmemory_import_vmctx(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of `VMMemoryImport`. + pub fn size_of_vmmemory_import(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for `VMMemoryDefinition`. +impl VMOffsets { + /// The offset of the `base` field. + #[allow(clippy::erasing_op)] + pub fn vmmemory_definition_base(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `current_length` field. + #[allow(clippy::identity_op)] + pub fn vmmemory_definition_current_length(&self) -> u8 { + 1 * self.pointer_size + } + + /// The size of the `current_length` field. + pub fn size_of_vmmemory_definition_current_length(&self) -> u8 { + 4 + } + + /// Return the size of `VMMemoryDefinition`. + pub fn size_of_vmmemory_definition(&self) -> u8 { + 2 * self.pointer_size + } + + /// The type of the `current_length` field. + pub fn type_of_vmmemory_definition_current_length(&self) -> ir::Type { + ir::Type::int(u16::from(self.size_of_vmmemory_definition_current_length()) * 8).unwrap() + } +} + +/// Offsets for `VMGlobalImport`. +impl VMOffsets { + /// The offset of the `from` field. + #[allow(clippy::erasing_op)] + pub fn vmglobal_import_from(&self) -> u8 { + 0 * self.pointer_size + } + + /// Return the size of `VMGlobalImport`. + #[allow(clippy::identity_op)] + pub fn size_of_vmglobal_import(&self) -> u8 { + 1 * self.pointer_size + } +} + +/// Offsets for `VMGlobalDefinition`. +impl VMOffsets { + /// Return the size of `VMGlobalDefinition`; this is the size of the largest value type (i.e. a + /// V128). + pub fn size_of_vmglobal_definition(&self) -> u8 { + 16 + } +} + +/// Offsets for `VMSharedSignatureIndex`. +impl VMOffsets { + /// Return the size of `VMSharedSignatureIndex`. + pub fn size_of_vmshared_signature_index(&self) -> u8 { + 4 + } +} + +/// Offsets for `VMCallerCheckedAnyfunc`. +impl VMOffsets { + /// The offset of the `func_ptr` field. + #[allow(clippy::erasing_op)] + pub fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `type_index` field. + #[allow(clippy::identity_op)] + pub fn vmcaller_checked_anyfunc_type_index(&self) -> u8 { + 1 * self.pointer_size + } + + /// The offset of the `vmctx` field. + pub fn vmcaller_checked_anyfunc_vmctx(&self) -> u8 { + 2 * self.pointer_size + } + + /// Return the size of `VMCallerCheckedAnyfunc`. + pub fn size_of_vmcaller_checked_anyfunc(&self) -> u8 { + 3 * self.pointer_size + } +} + +/// Offsets for `VMContext`. +impl VMOffsets { + /// The offset of the `signature_ids` array. + pub fn vmctx_signature_ids_begin(&self) -> u32 { + 0 + } + + /// The offset of the `tables` array. + #[allow(clippy::erasing_op)] + pub fn vmctx_imported_functions_begin(&self) -> u32 { + self.vmctx_signature_ids_begin() + .checked_add( + self.num_signature_ids + .checked_mul(u32::from(self.size_of_vmshared_signature_index())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `tables` array. + #[allow(clippy::identity_op)] + pub fn vmctx_imported_tables_begin(&self) -> u32 { + self.vmctx_imported_functions_begin() + .checked_add( + self.num_imported_functions + .checked_mul(u32::from(self.size_of_vmfunction_import())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `memories` array. + pub fn vmctx_imported_memories_begin(&self) -> u32 { + self.vmctx_imported_tables_begin() + .checked_add( + self.num_imported_tables + .checked_mul(u32::from(self.size_of_vmtable_import())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `globals` array. + pub fn vmctx_imported_globals_begin(&self) -> u32 { + self.vmctx_imported_memories_begin() + .checked_add( + self.num_imported_memories + .checked_mul(u32::from(self.size_of_vmmemory_import())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `tables` array. + pub fn vmctx_tables_begin(&self) -> u32 { + self.vmctx_imported_globals_begin() + .checked_add( + self.num_imported_globals + .checked_mul(u32::from(self.size_of_vmglobal_import())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `memories` array. + pub fn vmctx_memories_begin(&self) -> u32 { + self.vmctx_tables_begin() + .checked_add( + self.num_defined_tables + .checked_mul(u32::from(self.size_of_vmtable_definition())) + .unwrap(), + ) + .unwrap() + } + + /// The offset of the `globals` array. + pub fn vmctx_globals_begin(&self) -> u32 { + let offset = self + .vmctx_memories_begin() + .checked_add( + self.num_defined_memories + .checked_mul(u32::from(self.size_of_vmmemory_definition())) + .unwrap(), + ) + .unwrap(); + align(offset, 16) + } + + /// The offset of the builtin functions array. + pub fn vmctx_builtin_functions_begin(&self) -> u32 { + self.vmctx_globals_begin() + .checked_add( + self.num_defined_globals + .checked_mul(u32::from(self.size_of_vmglobal_definition())) + .unwrap(), + ) + .unwrap() + } + + /// Return the size of the `VMContext` allocation. + pub fn size_of_vmctx(&self) -> u32 { + self.vmctx_builtin_functions_begin() + .checked_add( + BuiltinFunctionIndex::builtin_functions_total_number() + .checked_mul(u32::from(self.pointer_size)) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMSharedSignatureId` index `index`. + pub fn vmctx_vmshared_signature_id(&self, index: SignatureIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_signature_ids); + self.vmctx_signature_ids_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmshared_signature_index())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMFunctionImport` index `index`. + pub fn vmctx_vmfunction_import(&self, index: FuncIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_functions); + self.vmctx_imported_functions_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmfunction_import())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMTableImport` index `index`. + pub fn vmctx_vmtable_import(&self, index: TableIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_tables); + self.vmctx_imported_tables_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmtable_import())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMMemoryImport` index `index`. + pub fn vmctx_vmmemory_import(&self, index: MemoryIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_memories); + self.vmctx_imported_memories_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmmemory_import())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMGlobalImport` index `index`. + pub fn vmctx_vmglobal_import(&self, index: GlobalIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_globals); + self.vmctx_imported_globals_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmglobal_import())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMTableDefinition` index `index`. + pub fn vmctx_vmtable_definition(&self, index: DefinedTableIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_defined_tables); + self.vmctx_tables_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmtable_definition())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to `VMMemoryDefinition` index `index`. + pub fn vmctx_vmmemory_definition(&self, index: DefinedMemoryIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_defined_memories); + self.vmctx_memories_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmmemory_definition())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to the `VMGlobalDefinition` index `index`. + pub fn vmctx_vmglobal_definition(&self, index: DefinedGlobalIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_defined_globals); + self.vmctx_globals_begin() + .checked_add( + index + .as_u32() + .checked_mul(u32::from(self.size_of_vmglobal_definition())) + .unwrap(), + ) + .unwrap() + } + + /// Return the offset to the `body` field in `*const VMFunctionBody` index `index`. + pub fn vmctx_vmfunction_import_body(&self, index: FuncIndex) -> u32 { + self.vmctx_vmfunction_import(index) + .checked_add(u32::from(self.vmfunction_import_body())) + .unwrap() + } + + /// Return the offset to the `vmctx` field in `*const VMFunctionBody` index `index`. + pub fn vmctx_vmfunction_import_vmctx(&self, index: FuncIndex) -> u32 { + self.vmctx_vmfunction_import(index) + .checked_add(u32::from(self.vmfunction_import_vmctx())) + .unwrap() + } + + /// Return the offset to the `from` field in `VMTableImport` index `index`. + pub fn vmctx_vmtable_import_from(&self, index: TableIndex) -> u32 { + self.vmctx_vmtable_import(index) + .checked_add(u32::from(self.vmtable_import_from())) + .unwrap() + } + + /// Return the offset to the `base` field in `VMTableDefinition` index `index`. + pub fn vmctx_vmtable_definition_base(&self, index: DefinedTableIndex) -> u32 { + self.vmctx_vmtable_definition(index) + .checked_add(u32::from(self.vmtable_definition_base())) + .unwrap() + } + + /// Return the offset to the `current_elements` field in `VMTableDefinition` index `index`. + pub fn vmctx_vmtable_definition_current_elements(&self, index: DefinedTableIndex) -> u32 { + self.vmctx_vmtable_definition(index) + .checked_add(u32::from(self.vmtable_definition_current_elements())) + .unwrap() + } + + /// Return the offset to the `from` field in `VMMemoryImport` index `index`. + pub fn vmctx_vmmemory_import_from(&self, index: MemoryIndex) -> u32 { + self.vmctx_vmmemory_import(index) + .checked_add(u32::from(self.vmmemory_import_from())) + .unwrap() + } + + /// Return the offset to the `vmctx` field in `VMMemoryImport` index `index`. + pub fn vmctx_vmmemory_import_vmctx(&self, index: MemoryIndex) -> u32 { + self.vmctx_vmmemory_import(index) + .checked_add(u32::from(self.vmmemory_import_vmctx())) + .unwrap() + } + + /// Return the offset to the `base` field in `VMMemoryDefinition` index `index`. + pub fn vmctx_vmmemory_definition_base(&self, index: DefinedMemoryIndex) -> u32 { + self.vmctx_vmmemory_definition(index) + .checked_add(u32::from(self.vmmemory_definition_base())) + .unwrap() + } + + /// Return the offset to the `current_length` field in `VMMemoryDefinition` index `index`. + pub fn vmctx_vmmemory_definition_current_length(&self, index: DefinedMemoryIndex) -> u32 { + self.vmctx_vmmemory_definition(index) + .checked_add(u32::from(self.vmmemory_definition_current_length())) + .unwrap() + } + + /// Return the offset to the `from` field in `VMGlobalImport` index `index`. + pub fn vmctx_vmglobal_import_from(&self, index: GlobalIndex) -> u32 { + self.vmctx_vmglobal_import(index) + .checked_add(u32::from(self.vmglobal_import_from())) + .unwrap() + } + + /// Return the offset to builtin function in `VMBuiltinFunctionsArray` index `index`. + pub fn vmctx_builtin_function(&self, index: BuiltinFunctionIndex) -> u32 { + self.vmctx_builtin_functions_begin() + .checked_add( + index + .index() + .checked_mul(u32::from(self.pointer_size)) + .unwrap(), + ) + .unwrap() + } +} + +/// Target specific type for shared signature index. +#[derive(Debug, Copy, Clone)] +pub struct TargetSharedSignatureIndex(u32); + +impl TargetSharedSignatureIndex { + /// Constructs `TargetSharedSignatureIndex`. + pub fn new(value: u32) -> Self { + Self(value) + } + + /// Returns index value. + pub fn index(self) -> u32 { + self.0 + } +} + +#[cfg(test)] +mod tests { + use crate::vmoffsets::align; + + #[test] + fn alignment() { + fn is_aligned(x: u32) -> bool { + x % 16 == 0 + } + assert!(is_aligned(align(0, 16))); + assert!(is_aligned(align(32, 16))); + assert!(is_aligned(align(33, 16))); + assert!(is_aligned(align(31, 16))); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +
+//! Test case generators. +//! +//! Test case generators take raw, unstructured input from a fuzzer +//! (e.g. libFuzzer) and translate that into a structured test case (e.g. a +//! valid Wasm binary). +//! +//! These are generally implementations of the `Arbitrary` trait, or some +//! wrapper over an external tool, such that the wrapper implements the +//! `Arbitrary` trait for the wrapped external tool. + +pub mod api; + +use arbitrary::{Arbitrary, Unstructured}; +use std::fmt; + +/// A Wasm test case generator that is powered by Binaryen's `wasm-opt -ttf`. +#[derive(Clone)] +pub struct WasmOptTtf { + /// The raw, encoded Wasm bytes. + pub wasm: Vec<u8>, +} + +impl fmt::Debug for WasmOptTtf { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "WasmOptTtf {{ wasm: wat::parse_str(r###\"\n{}\n\"###).unwrap() }}", + wasmprinter::print_bytes(&self.wasm).expect("valid wasm should always disassemble") + ) + } +} + +impl Arbitrary for WasmOptTtf { + fn arbitrary(input: &mut Unstructured) -> arbitrary::Result<Self> { + let seed: Vec<u8> = Arbitrary::arbitrary(input)?; + let module = binaryen::tools::translate_to_fuzz_mvp(&seed); + let wasm = module.write(); + Ok(WasmOptTtf { wasm }) + } + + fn arbitrary_take_rest(input: Unstructured) -> arbitrary::Result<Self> { + let seed: Vec<u8> = Arbitrary::arbitrary_take_rest(input)?; + let module = binaryen::tools::translate_to_fuzz_mvp(&seed); + let wasm = module.write(); + Ok(WasmOptTtf { wasm }) + } +} + +/// A description of configuration options that we should do differential +/// testing between. +#[derive(Arbitrary, Clone, Debug, PartialEq, Eq, Hash)] +pub struct DifferentialConfig { + strategy: DifferentialStrategy, + opt_level: DifferentialOptLevel, +} + +impl DifferentialConfig { + /// Convert this differential fuzzing config into a `wasmtime::Config`. + pub fn to_wasmtime_config(&self) -> anyhow::Result<wasmtime::Config> { + let mut config = wasmtime::Config::new(); + config.strategy(match self.strategy { + DifferentialStrategy::Cranelift => wasmtime::Strategy::Cranelift, + DifferentialStrategy::Lightbeam => wasmtime::Strategy::Lightbeam, + })?; + config.cranelift_opt_level(match self.opt_level { + DifferentialOptLevel::None => wasmtime::OptLevel::None, + DifferentialOptLevel::Speed => wasmtime::OptLevel::Speed, + DifferentialOptLevel::SpeedAndSize => wasmtime::OptLevel::SpeedAndSize, + }); + Ok(config) + } +} + +#[derive(Arbitrary, Clone, Debug, PartialEq, Eq, Hash)] +enum DifferentialStrategy { + Cranelift, + Lightbeam, +} + +#[derive(Arbitrary, Clone, Debug, PartialEq, Eq, Hash)] +enum DifferentialOptLevel { + None, + Speed, + SpeedAndSize, +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +
+//! Generating sequences of Wasmtime API calls. +//! +//! We only generate *valid* sequences of API calls. To do this, we keep track +//! of what objects we've already created in earlier API calls via the `Scope` +//! struct. +//! +//! To generate even-more-pathological sequences of API calls, we use [swarm +//! testing]: +//! +//! > In swarm testing, the usual practice of potentially including all features +//! > in every test case is abandoned. Rather, a large “swarm” of randomly +//! > generated configurations, each of which omits some features, is used, with +//! > configurations receiving equal resources. +//! +//! [swarm testing]: https://www.cs.utah.edu/~regehr/papers/swarm12.pdf + +use arbitrary::{Arbitrary, Unstructured}; +use std::collections::BTreeSet; + +#[derive(Arbitrary, Debug)] +struct Swarm { + config_debug_info: bool, + module_new: bool, + module_drop: bool, + instance_new: bool, + instance_drop: bool, + call_exported_func: bool, +} + +/// A call to one of Wasmtime's public APIs. +#[derive(Arbitrary, Clone, Debug)] +#[allow(missing_docs)] +pub enum ApiCall { + ConfigNew, + ConfigDebugInfo(bool), + EngineNew, + StoreNew, + ModuleNew { id: usize, wasm: super::WasmOptTtf }, + ModuleDrop { id: usize }, + InstanceNew { id: usize, module: usize }, + InstanceDrop { id: usize }, + CallExportedFunc { instance: usize, nth: usize }, +} +use ApiCall::*; + +#[derive(Default)] +struct Scope { + id_counter: usize, + modules: BTreeSet<usize>, + instances: BTreeSet<usize>, +} + +impl Scope { + fn next_id(&mut self) -> usize { + let id = self.id_counter; + self.id_counter = id + 1; + id + } +} + +/// A sequence of API calls. +#[derive(Debug)] +pub struct ApiCalls { + /// The API calls. + pub calls: Vec<ApiCall>, +} + +impl Arbitrary for ApiCalls { + fn arbitrary(input: &mut Unstructured) -> arbitrary::Result<Self> { + let swarm = Swarm::arbitrary(input)?; + let mut calls = vec![]; + + arbitrary_config(input, &swarm, &mut calls)?; + calls.push(EngineNew); + calls.push(StoreNew); + + let mut scope = Scope::default(); + + for _ in 0..input.arbitrary_len::<ApiCall>()? { + let mut choices: Vec<fn(_, &mut Scope) -> arbitrary::Result<ApiCall>> = vec![]; + + if swarm.module_new { + choices.push(|input, scope| { + let id = scope.next_id(); + scope.modules.insert(id); + let wasm = super::WasmOptTtf::arbitrary(input)?; + Ok(ModuleNew { id, wasm }) + }); + } + if swarm.module_drop && !scope.modules.is_empty() { + choices.push(|input, scope| { + let modules: Vec<_> = scope.modules.iter().cloned().collect(); + let id = *input.choose(&modules)?; + scope.modules.remove(&id); + Ok(ModuleDrop { id }) + }); + } + if swarm.instance_new && !scope.modules.is_empty() { + choices.push(|input, scope| { + let modules: Vec<_> = scope.modules.iter().cloned().collect(); + let module = *input.choose(&modules)?; + let id = scope.next_id(); + scope.instances.insert(id); + Ok(InstanceNew { id, module }) + }); + } + if swarm.instance_drop && !scope.instances.is_empty() { + choices.push(|input, scope| { + let instances: Vec<_> = scope.instances.iter().cloned().collect(); + let id = *input.choose(&instances)?; + scope.instances.remove(&id); + Ok(InstanceDrop { id }) + }); + } + if swarm.call_exported_func && !scope.instances.is_empty() { + choices.push(|input, scope| { + let instances: Vec<_> = scope.instances.iter().cloned().collect(); + let instance = *input.choose(&instances)?; + let nth = usize::arbitrary(input)?; + Ok(CallExportedFunc { instance, nth }) + }); + } + + if choices.is_empty() { + break; + } + let c = input.choose(&choices)?; + calls.push(c(input, &mut scope)?); + } + + Ok(ApiCalls { calls }) + } +} + +fn arbitrary_config( + input: &mut Unstructured, + swarm: &Swarm, + calls: &mut Vec<ApiCall>, +) -> arbitrary::Result<()> { + calls.push(ConfigNew); + + if swarm.config_debug_info && bool::arbitrary(input)? { + calls.push(ConfigDebugInfo(bool::arbitrary(input)?)); + } + + // TODO: flags, features, and compilation strategy. + + Ok(()) +} +
1 +2 +3 +4 +5 +6 +
+//! Fuzzing infrastructure for Wasmtime. + +#![deny(missing_docs, missing_debug_implementations)] + +pub mod generators; +pub mod oracles; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +
+//! Oracles. +//! +//! Oracles take a test case and determine whether we have a bug. For example, +//! one of the simplest oracles is to take a Wasm binary as our input test case, +//! validate and instantiate it, and (implicitly) check that no assertions +//! failed or segfaults happened. A more complicated oracle might compare the +//! result of executing a Wasm file with and without optimizations enabled, and +//! make sure that the two executions are observably identical. +//! +//! When an oracle finds a bug, it should report it to the fuzzing engine by +//! panicking. + +pub mod dummy; + +use dummy::{dummy_imports, dummy_values}; +use std::collections::{HashMap, HashSet}; +use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; +use wasmtime::*; + +fn fuzz_default_config(strategy: Strategy) -> Config { + drop(env_logger::try_init()); + let mut config = Config::new(); + config + .cranelift_debug_verifier(true) + .wasm_multi_value(true) + .strategy(strategy) + .expect("failed to enable lightbeam"); + return config; +} + +fn log_wasm(wasm: &[u8]) { + static CNT: AtomicUsize = AtomicUsize::new(0); + if !log::log_enabled!(log::Level::Debug) { + return; + } + + let i = CNT.fetch_add(1, SeqCst); + let name = format!("testcase{}.wasm", i); + std::fs::write(&name, wasm).expect("failed to write wasm file"); + log::debug!("wrote wasm file to `{}`", name); + if let Ok(s) = wasmprinter::print_bytes(wasm) { + let name = format!("testcase{}.wat", i); + std::fs::write(&name, s).expect("failed to write wat file"); + } +} + +/// Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +/// panic or segfault or anything else that can be detected "passively". +/// +/// Performs initial validation, and returns early if the Wasm is invalid. +/// +/// You can control which compiler is used via passing a `Strategy`. +pub fn instantiate(wasm: &[u8], strategy: Strategy) { + instantiate_with_config(wasm, fuzz_default_config(strategy)); +} + +/// Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +/// panic or segfault or anything else that can be detected "passively". +/// +/// The engine will be configured using provided config. +/// +/// See also `instantiate` functions. +pub fn instantiate_with_config(wasm: &[u8], config: Config) { + let engine = Engine::new(&config); + let store = Store::new(&engine); + + log_wasm(wasm); + let module = match Module::new(&store, wasm) { + Ok(module) => module, + Err(_) => return, + }; + + let imports = match dummy_imports(&store, module.imports()) { + Ok(imps) => imps, + Err(_) => { + // There are some value types that we can't synthesize a + // dummy value for (e.g. anyrefs) and for modules that + // import things of these types we skip instantiation. + return; + } + }; + + // Don't unwrap this: there can be instantiation-/link-time errors that + // aren't caught during validation or compilation. For example, an imported + // table might not have room for an element segment that we want to + // initialize into it. + let _result = Instance::new(&module, &imports); +} + +/// Compile the Wasm buffer, and implicitly fail if we have an unexpected +/// panic or segfault or anything else that can be detected "passively". +/// +/// Performs initial validation, and returns early if the Wasm is invalid. +/// +/// You can control which compiler is used via passing a `Strategy`. +pub fn compile(wasm: &[u8], strategy: Strategy) { + let engine = Engine::new(&fuzz_default_config(strategy)); + let store = Store::new(&engine); + log_wasm(wasm); + let _ = Module::new(&store, wasm); +} + +/// Instantiate the given Wasm module with each `Config` and call all of its +/// exports. Modulo OOM, non-canonical NaNs, and usage of Wasm features that are +/// or aren't enabled for different configs, we should get the same results when +/// we call the exported functions for all of our different configs. +pub fn differential_execution( + ttf: &crate::generators::WasmOptTtf, + configs: &[crate::generators::DifferentialConfig], +) { + drop(env_logger::try_init()); + // We need at least two configs. + if configs.len() < 2 + // And all the configs should be unique. + || configs.iter().collect::<HashSet<_>>().len() != configs.len() + { + return; + } + + let configs: Vec<_> = match configs.iter().map(|c| c.to_wasmtime_config()).collect() { + Ok(cs) => cs, + // If the config is trying to use something that was turned off at + // compile time, eg lightbeam, just continue to the next fuzz input. + Err(_) => return, + }; + + let mut export_func_results: HashMap<String, Result<Box<[Val]>, Trap>> = Default::default(); + log_wasm(&ttf.wasm); + + for config in &configs { + let engine = Engine::new(config); + let store = Store::new(&engine); + + let module = match Module::new(&store, &ttf.wasm) { + Ok(module) => module, + // The module might rely on some feature that our config didn't + // enable or something like that. + Err(e) => { + eprintln!("Warning: failed to compile `wasm-opt -ttf` module: {}", e); + continue; + } + }; + + // TODO: we should implement tracing versions of these dummy imports + // that record a trace of the order that imported functions were called + // in and with what values. Like the results of exported functions, + // calls to imports should also yield the same values for each + // configuration, and we should assert that. + let imports = match dummy_imports(&store, module.imports()) { + Ok(imps) => imps, + Err(e) => { + // There are some value types that we can't synthesize a + // dummy value for (e.g. anyrefs) and for modules that + // import things of these types we skip instantiation. + eprintln!("Warning: failed to synthesize dummy imports: {}", e); + continue; + } + }; + + // Don't unwrap this: there can be instantiation-/link-time errors that + // aren't caught during validation or compilation. For example, an imported + // table might not have room for an element segment that we want to + // initialize into it. + let instance = match Instance::new(&module, &imports) { + Ok(instance) => instance, + Err(e) => { + eprintln!( + "Warning: failed to instantiate `wasm-opt -ttf` module: {}", + e + ); + continue; + } + }; + + let funcs = module + .exports() + .iter() + .filter_map(|e| { + if let ExternType::Func(_) = e.ty() { + Some(e.name()) + } else { + None + } + }) + .collect::<Vec<_>>(); + + for name in funcs { + // Always call the hang limit initializer first, so that we don't + // infinite loop when calling another export. + init_hang_limit(&instance); + + let f = match instance + .get_export(&name) + .expect("instance should have export from module") + { + Extern::Func(f) => f.clone(), + _ => panic!("export should be a function"), + }; + + let ty = f.ty(); + let params = match dummy_values(ty.params()) { + Ok(p) => p, + Err(_) => continue, + }; + let this_result = f.call(¶ms); + + let existing_result = export_func_results + .entry(name.to_string()) + .or_insert_with(|| this_result.clone()); + assert_same_export_func_result(&existing_result, &this_result, name); + } + } +} + +fn init_hang_limit(instance: &Instance) { + match instance.get_export("hangLimitInitializer") { + None => return, + Some(Extern::Func(f)) => { + f.call(&[]) + .expect("initializing the hang limit should not fail"); + } + Some(_) => panic!("unexpected hangLimitInitializer export"), + } +} + +fn assert_same_export_func_result( + lhs: &Result<Box<[Val]>, Trap>, + rhs: &Result<Box<[Val]>, Trap>, + func_name: &str, +) { + let fail = || { + panic!( + "differential fuzzing failed: exported func {} returned two \ + different results: {:?} != {:?}", + func_name, lhs, rhs + ) + }; + + match (lhs, rhs) { + (Err(_), Err(_)) => {} + (Ok(lhs), Ok(rhs)) => { + if lhs.len() != rhs.len() { + fail(); + } + for (lhs, rhs) in lhs.iter().zip(rhs.iter()) { + match (lhs, rhs) { + (Val::I32(lhs), Val::I32(rhs)) if lhs == rhs => continue, + (Val::I64(lhs), Val::I64(rhs)) if lhs == rhs => continue, + (Val::V128(lhs), Val::V128(rhs)) if lhs == rhs => continue, + (Val::F32(lhs), Val::F32(rhs)) => { + let lhs = f32::from_bits(*lhs); + let rhs = f32::from_bits(*rhs); + if lhs == rhs || (lhs.is_nan() && rhs.is_nan()) { + continue; + } else { + fail() + } + } + (Val::F64(lhs), Val::F64(rhs)) => { + let lhs = f64::from_bits(*lhs); + let rhs = f64::from_bits(*rhs); + if lhs == rhs || (lhs.is_nan() && rhs.is_nan()) { + continue; + } else { + fail() + } + } + (Val::AnyRef(_), Val::AnyRef(_)) | (Val::FuncRef(_), Val::FuncRef(_)) => { + continue + } + _ => fail(), + } + } + } + _ => fail(), + } +} + +/// Invoke the given API calls. +pub fn make_api_calls(api: crate::generators::api::ApiCalls) { + use crate::generators::api::ApiCall; + + drop(env_logger::try_init()); + + let mut config: Option<Config> = None; + let mut engine: Option<Engine> = None; + let mut store: Option<Store> = None; + let mut modules: HashMap<usize, Module> = Default::default(); + let mut instances: HashMap<usize, Instance> = Default::default(); + + for call in api.calls { + match call { + ApiCall::ConfigNew => { + log::trace!("creating config"); + assert!(config.is_none()); + let mut cfg = Config::new(); + cfg.cranelift_debug_verifier(true); + config = Some(cfg); + } + + ApiCall::ConfigDebugInfo(b) => { + log::trace!("enabling debuginfo"); + config.as_mut().unwrap().debug_info(b); + } + + ApiCall::EngineNew => { + log::trace!("creating engine"); + assert!(engine.is_none()); + engine = Some(Engine::new(config.as_ref().unwrap())); + } + + ApiCall::StoreNew => { + log::trace!("creating store"); + assert!(store.is_none()); + store = Some(Store::new(engine.as_ref().unwrap())); + } + + ApiCall::ModuleNew { id, wasm } => { + log::debug!("creating module: {}", id); + log_wasm(&wasm.wasm); + let module = match Module::new(store.as_ref().unwrap(), &wasm.wasm) { + Ok(m) => m, + Err(_) => continue, + }; + let old = modules.insert(id, module); + assert!(old.is_none()); + } + + ApiCall::ModuleDrop { id } => { + log::trace!("dropping module: {}", id); + drop(modules.remove(&id)); + } + + ApiCall::InstanceNew { id, module } => { + log::trace!("instantiating module {} as {}", module, id); + let module = match modules.get(&module) { + Some(m) => m, + None => continue, + }; + + let imports = match dummy_imports(store.as_ref().unwrap(), module.imports()) { + Ok(imps) => imps, + Err(_) => { + // There are some value types that we can't synthesize a + // dummy value for (e.g. anyrefs) and for modules that + // import things of these types we skip instantiation. + continue; + } + }; + + // Don't unwrap this: there can be instantiation-/link-time errors that + // aren't caught during validation or compilation. For example, an imported + // table might not have room for an element segment that we want to + // initialize into it. + if let Ok(instance) = Instance::new(&module, &imports) { + instances.insert(id, instance); + } + } + + ApiCall::InstanceDrop { id } => { + log::trace!("dropping instance {}", id); + drop(instances.remove(&id)); + } + + ApiCall::CallExportedFunc { instance, nth } => { + log::trace!("calling instance export {} / {}", instance, nth); + let instance = match instances.get(&instance) { + Some(i) => i, + None => { + // Note that we aren't guaranteed to instantiate valid + // modules, see comments in `InstanceNew` for details on + // that. But the API call generator can't know if + // instantiation failed, so we might not actually have + // this instance. When that's the case, just skip the + // API call and keep going. + continue; + } + }; + + let funcs = instance + .exports() + .iter() + .filter_map(|e| match e { + Extern::Func(f) => Some(f.clone()), + _ => None, + }) + .collect::<Vec<_>>(); + + if funcs.is_empty() { + continue; + } + + let nth = nth % funcs.len(); + let f = &funcs[nth]; + let ty = f.ty(); + let params = match dummy_values(ty.params()) { + Ok(p) => p, + Err(_) => continue, + }; + let _ = f.call(¶ms); + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +
+//! Dummy implementations of things that a Wasm module can import. + +use std::rc::Rc; +use wasmtime::{ + Callable, Extern, ExternType, Func, FuncType, Global, GlobalType, ImportType, Memory, + MemoryType, Store, Table, TableType, Trap, Val, ValType, +}; + +/// Create a set of dummy functions/globals/etc for the given imports. +pub fn dummy_imports(store: &Store, import_tys: &[ImportType]) -> Result<Vec<Extern>, Trap> { + let mut imports = Vec::with_capacity(import_tys.len()); + for imp in import_tys { + imports.push(match imp.ty() { + ExternType::Func(func_ty) => Extern::Func(DummyFunc::new(&store, func_ty.clone())), + ExternType::Global(global_ty) => { + Extern::Global(dummy_global(&store, global_ty.clone())?) + } + ExternType::Table(table_ty) => Extern::Table(dummy_table(&store, table_ty.clone())?), + ExternType::Memory(mem_ty) => Extern::Memory(dummy_memory(&store, mem_ty.clone())), + }); + } + Ok(imports) +} + +/// A function that doesn't do anything but return the default (zero) value for +/// the function's type. +#[derive(Debug)] +pub struct DummyFunc(FuncType); + +impl DummyFunc { + /// Construct a new dummy `Func`. + pub fn new(store: &Store, ty: FuncType) -> Func { + let callable = DummyFunc(ty.clone()); + Func::new(store, ty, Rc::new(callable) as _) + } +} + +impl Callable for DummyFunc { + fn call(&self, _params: &[Val], results: &mut [Val]) -> Result<(), Trap> { + for (ret_ty, result) in self.0.results().iter().zip(results) { + *result = dummy_value(ret_ty)?; + } + + Ok(()) + } +} + +/// Construct a dummy value for the given value type. +pub fn dummy_value(val_ty: &ValType) -> Result<Val, Trap> { + Ok(match val_ty { + ValType::I32 => Val::I32(0), + ValType::I64 => Val::I64(0), + ValType::F32 => Val::F32(0), + ValType::F64 => Val::F64(0), + ValType::V128 => { + return Err(Trap::new( + "dummy_value: unsupported function return type: v128".to_string(), + )) + } + ValType::AnyRef => { + return Err(Trap::new( + "dummy_value: unsupported function return type: anyref".to_string(), + )) + } + ValType::FuncRef => { + return Err(Trap::new( + "dummy_value: unsupported function return type: funcref".to_string(), + )) + } + }) +} + +/// Construct a sequence of dummy values for the given types. +pub fn dummy_values(val_tys: &[ValType]) -> Result<Vec<Val>, Trap> { + val_tys.iter().map(dummy_value).collect() +} + +/// Construct a dummy global for the given global type. +pub fn dummy_global(store: &Store, ty: GlobalType) -> Result<Global, Trap> { + let val = dummy_value(ty.content())?; + Ok(Global::new(store, ty, val).unwrap()) +} + +/// Construct a dummy table for the given table type. +pub fn dummy_table(store: &Store, ty: TableType) -> Result<Table, Trap> { + let init_val = dummy_value(&ty.element())?; + Ok(Table::new(store, ty, init_val).unwrap()) +} + +/// Construct a dummy memory for the given memory type. +pub fn dummy_memory(store: &Store, ty: MemoryType) -> Memory { + Memory::new(store, ty) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +
+//! A small crate to handle WebAssembly interface types in wasmtime. +//! +//! Note that this is intended to follow the [official proposal][proposal] and +//! is highly susceptible to change/breakage/etc. +//! +//! [proposal]: https://github.com/webassembly/webidl-bindings + +#![deny(missing_docs)] + +use anyhow::{bail, format_err, Result}; +use std::convert::TryFrom; +use std::str; +use wasm_webidl_bindings::ast; +use wasmtime::Val; +use wasmtime_environ::ir; +use wasmtime_runtime::{Export, InstanceHandle}; + +mod value; +pub use value::Value; + +/// A data structure intended to hold a parsed representation of the wasm +/// interface types of a module. +/// +/// The expected usage pattern is to create this next to wasmtime data +/// structures and then use this to process arguments into wasm arguments as +/// appropriate for bound functions. +pub struct ModuleData { + inner: Option<Inner>, + wasi_module_name: Option<String>, +} + +struct Inner { + module: walrus::Module, +} + +/// Representation of a binding of an exported function. +/// +/// Can be used to learn about binding expressions and/or binding types. +pub struct ExportBinding<'a> { + kind: ExportBindingKind<'a>, +} + +enum ExportBindingKind<'a> { + Rich { + section: &'a ast::WebidlBindings, + binding: &'a ast::ExportBinding, + }, + Raw(ir::Signature), +} + +impl ModuleData { + /// Parses a raw binary wasm file, extracting information about wasm + /// interface types. + /// + /// Returns an error if the wasm file is malformed. + pub fn new(wasm: &[u8]) -> Result<ModuleData> { + // Perform a fast search through the module for the right custom + // section. Actually parsing out the interface types data is currently a + // pretty expensive operation so we want to only do that if we actually + // find the right section. + let mut reader = wasmparser::ModuleReader::new(wasm)?; + let mut found = false; + let mut wasi_module_name = None; + while !reader.eof() { + let section = reader.read()?; + + match section.code { + wasmparser::SectionCode::Custom { name, .. } => { + if name == "webidl-bindings" { + found = true; + break; + } + } + + // If we see the import section then see if we can find a wasi + // module import which we can later use to register the wasi + // implementation automatically. + wasmparser::SectionCode::Import => { + let section = section.get_import_section_reader()?; + for import in section { + let import = import?; + if wasmtime_wasi::is_wasi_module(import.module) { + wasi_module_name = Some(import.module.to_string()); + } + } + } + _ => {} + } + } + if !found { + return Ok(ModuleData { + inner: None, + wasi_module_name, + }); + } + + // Ok, perform the more expensive parsing. WebAssembly interface types + // are super experimental and under development. To get something + // quickly up and running we're using the same crate as `wasm-bindgen`, + // a producer of wasm interface types, the `wasm-webidl-bindings` crate. + // This crate relies on `walrus` which has its own IR for a wasm module. + // Ideally we'd do all this during cranelift's own parsing of the wasm + // module and we wouldn't have to reparse here purely for this one use + // case. + // + // For now though this is "fast enough" and good enough for some demos, + // but for full-on production quality engines we'll want to integrate + // this much more tightly with the rest of wasmtime. + let module = walrus::ModuleConfig::new() + .on_parse(wasm_webidl_bindings::binary::on_parse) + .parse(wasm)?; + + Ok(ModuleData { + inner: Some(Inner { module }), + wasi_module_name, + }) + } + + /// Detects if WASI support is needed: returns module name that is requested. + pub fn find_wasi_module_name(&self) -> Option<String> { + self.wasi_module_name.clone() + } + + /// Invokes wasmtime function with a `&[Value]` list. `Value` the set of + /// wasm interface types. + pub fn invoke_export( + &self, + instance: &wasmtime::Instance, + export: &str, + args: &[Value], + ) -> Result<Vec<Value>> { + let mut handle = instance.handle().clone(); + + let binding = self.binding_for_export(&mut handle, export)?; + let incoming = binding.param_bindings()?; + let outgoing = binding.result_bindings()?; + + let f = instance + .get_export(export) + .ok_or_else(|| format_err!("failed to find export `{}`", export))? + .func() + .ok_or_else(|| format_err!("`{}` is not a function", export))? + .clone(); + + let mut cx = InstanceTranslateContext(instance.clone()); + let wasm_args = translate_incoming(&mut cx, &incoming, args)? + .into_iter() + .map(|rv| rv.into()) + .collect::<Vec<_>>(); + let wasm_results = f.call(&wasm_args)?; + translate_outgoing(&mut cx, &outgoing, &wasm_results) + } + + /// Returns an appropriate binding for the `name` export in this module + /// which has also been instantiated as `instance` provided here. + /// + /// Returns an error if `name` is not present in the module. + pub fn binding_for_export( + &self, + instance: &mut InstanceHandle, + name: &str, + ) -> Result<ExportBinding<'_>> { + if let Some(binding) = self.interface_binding_for_export(name) { + return Ok(binding); + } + let signature = match instance.lookup(name) { + Some(Export::Function { signature, .. }) => signature, + Some(_) => bail!("`{}` is not a function", name), + None => bail!("failed to find export `{}`", name), + }; + Ok(ExportBinding { + kind: ExportBindingKind::Raw(signature), + }) + } + + fn interface_binding_for_export(&self, name: &str) -> Option<ExportBinding<'_>> { + let inner = self.inner.as_ref()?; + let bindings = inner.module.customs.get_typed::<ast::WebidlBindings>()?; + let export = inner.module.exports.iter().find(|e| e.name == name)?; + let id = match export.item { + walrus::ExportItem::Function(f) => f, + _ => panic!(), + }; + let (_, bind) = bindings.binds.iter().find(|(_, b)| b.func == id)?; + let binding = bindings.bindings.get(bind.binding)?; + let binding = match binding { + ast::FunctionBinding::Export(export) => export, + ast::FunctionBinding::Import(_) => return None, + }; + Some(ExportBinding { + kind: ExportBindingKind::Rich { + binding, + section: bindings, + }, + }) + } +} + +impl ExportBinding<'_> { + /// Returns the list of binding expressions used to create the parameters + /// for this binding. + pub fn param_bindings(&self) -> Result<Vec<ast::IncomingBindingExpression>> { + match &self.kind { + ExportBindingKind::Rich { binding, .. } => Ok(binding.params.bindings.clone()), + ExportBindingKind::Raw(sig) => sig + .params + .iter() + .skip(2) // skip the VMContext arguments + .enumerate() + .map(|(i, param)| default_incoming(i, param)) + .collect(), + } + } + + /// Returns the list of scalar types used for this binding + pub fn param_types(&self) -> Result<Vec<ast::WebidlScalarType>> { + match &self.kind { + ExportBindingKind::Rich { + binding, section, .. + } => { + let id = match binding.webidl_ty { + ast::WebidlTypeRef::Id(id) => id, + ast::WebidlTypeRef::Scalar(_) => { + bail!("webidl types for functions cannot be scalar") + } + }; + let ty = section + .types + .get::<ast::WebidlCompoundType>(id) + .ok_or_else(|| format_err!("invalid webidl custom section"))?; + let func = match ty { + ast::WebidlCompoundType::Function(f) => f, + _ => bail!("webidl type for function must be of function type"), + }; + func.params + .iter() + .map(|param| match param { + ast::WebidlTypeRef::Id(_) => bail!("function arguments cannot be compound"), + ast::WebidlTypeRef::Scalar(s) => Ok(*s), + }) + .collect() + } + ExportBindingKind::Raw(sig) => sig.params.iter().skip(2).map(abi2ast).collect(), + } + } + + /// Returns the list of binding expressions used to extract the return + /// values of this binding. + pub fn result_bindings(&self) -> Result<Vec<ast::OutgoingBindingExpression>> { + match &self.kind { + ExportBindingKind::Rich { binding, .. } => Ok(binding.result.bindings.clone()), + ExportBindingKind::Raw(sig) => sig + .returns + .iter() + .enumerate() + .map(|(i, param)| default_outgoing(i, param)) + .collect(), + } + } +} + +fn default_incoming(idx: usize, param: &ir::AbiParam) -> Result<ast::IncomingBindingExpression> { + let get = ast::IncomingBindingExpressionGet { idx: idx as u32 }; + let ty = if param.value_type == ir::types::I32 { + walrus::ValType::I32 + } else if param.value_type == ir::types::I64 { + walrus::ValType::I64 + } else if param.value_type == ir::types::F32 { + walrus::ValType::F32 + } else if param.value_type == ir::types::F64 { + walrus::ValType::F64 + } else { + bail!("unsupported type {:?}", param.value_type) + }; + Ok(ast::IncomingBindingExpressionAs { + ty, + expr: Box::new(get.into()), + } + .into()) +} + +fn default_outgoing(idx: usize, param: &ir::AbiParam) -> Result<ast::OutgoingBindingExpression> { + let ty = abi2ast(param)?; + Ok(ast::OutgoingBindingExpressionAs { + ty: ty.into(), + idx: idx as u32, + } + .into()) +} + +fn abi2ast(param: &ir::AbiParam) -> Result<ast::WebidlScalarType> { + Ok(if param.value_type == ir::types::I32 { + ast::WebidlScalarType::Long + } else if param.value_type == ir::types::I64 { + ast::WebidlScalarType::LongLong + } else if param.value_type == ir::types::F32 { + ast::WebidlScalarType::UnrestrictedFloat + } else if param.value_type == ir::types::F64 { + ast::WebidlScalarType::UnrestrictedDouble + } else { + bail!("unsupported type {:?}", param.value_type) + }) +} + +trait TranslateContext { + fn invoke_alloc(&mut self, alloc_func_name: &str, len: i32) -> Result<i32>; + unsafe fn get_memory(&mut self) -> Result<&mut [u8]>; +} + +struct InstanceTranslateContext(pub wasmtime::Instance); + +impl TranslateContext for InstanceTranslateContext { + fn invoke_alloc(&mut self, alloc_func_name: &str, len: i32) -> Result<i32> { + let alloc = self + .0 + .get_export(alloc_func_name) + .ok_or_else(|| format_err!("failed to find alloc function `{}`", alloc_func_name))? + .func() + .ok_or_else(|| format_err!("`{}` is not a (alloc) function", alloc_func_name))? + .clone(); + let alloc_args = vec![wasmtime::Val::I32(len)]; + let results = alloc.call(&alloc_args)?; + if results.len() != 1 { + bail!("allocator function wrong number of results"); + } + Ok(match results[0] { + wasmtime::Val::I32(i) => i, + _ => bail!("allocator function bad return type"), + }) + } + unsafe fn get_memory(&mut self) -> Result<&mut [u8]> { + let memory = self + .0 + .get_export("memory") + .ok_or_else(|| format_err!("failed to find `memory` export"))? + .memory() + .ok_or_else(|| format_err!("`memory` is not a memory"))? + .clone(); + let ptr = memory.data_ptr(); + let len = memory.data_size(); + Ok(std::slice::from_raw_parts_mut(ptr, len)) + } +} + +fn translate_incoming( + cx: &mut dyn TranslateContext, + bindings: &[ast::IncomingBindingExpression], + args: &[Value], +) -> Result<Vec<Val>> { + let get = |expr: &ast::IncomingBindingExpression| match expr { + ast::IncomingBindingExpression::Get(g) => args + .get(g.idx as usize) + .ok_or_else(|| format_err!("argument index out of bounds: {}", g.idx)), + _ => bail!("unsupported incoming binding expr {:?}", expr), + }; + + let mut copy = |alloc_func_name: &str, bytes: &[u8]| -> Result<(i32, i32)> { + let len = i32::try_from(bytes.len()).map_err(|_| format_err!("length overflow"))?; + let ptr = cx.invoke_alloc(alloc_func_name, len)?; + unsafe { + let raw = cx.get_memory()?; + raw[ptr as usize..][..bytes.len()].copy_from_slice(bytes) + } + + Ok((ptr, len)) + }; + + let mut wasm = Vec::new(); + + for expr in bindings { + match expr { + ast::IncomingBindingExpression::AllocUtf8Str(g) => { + let val = match get(&g.expr)? { + Value::String(s) => s, + _ => bail!("expected a string"), + }; + let (ptr, len) = copy(&g.alloc_func_name, val.as_bytes())?; + wasm.push(Val::I32(ptr)); + wasm.push(Val::I32(len)); + } + ast::IncomingBindingExpression::As(g) => { + let val = get(&g.expr)?; + match g.ty { + walrus::ValType::I32 => match val { + Value::I32(i) => wasm.push(Val::I32(*i)), + Value::U32(i) => wasm.push(Val::I32(*i as i32)), + _ => bail!("cannot convert {:?} to `i32`", val), + }, + walrus::ValType::I64 => match val { + Value::I32(i) => wasm.push(Val::I64((*i).into())), + Value::U32(i) => wasm.push(Val::I64((*i).into())), + Value::I64(i) => wasm.push(Val::I64(*i)), + Value::U64(i) => wasm.push(Val::I64(*i as i64)), + _ => bail!("cannot convert {:?} to `i64`", val), + }, + walrus::ValType::F32 => match val { + Value::F32(i) => wasm.push(Val::F32(i.to_bits())), + _ => bail!("cannot convert {:?} to `f32`", val), + }, + walrus::ValType::F64 => match val { + Value::F32(i) => wasm.push(Val::F64((*i as f64).to_bits())), + Value::F64(i) => wasm.push(Val::F64(i.to_bits())), + _ => bail!("cannot convert {:?} to `f64`", val), + }, + walrus::ValType::V128 | walrus::ValType::Anyref => { + bail!("unsupported `as` type {:?}", g.ty); + } + } + } + _ => bail!("unsupported incoming binding expr {:?}", expr), + } + } + + Ok(wasm) +} + +fn translate_outgoing( + cx: &mut dyn TranslateContext, + bindings: &[ast::OutgoingBindingExpression], + args: &[Val], +) -> Result<Vec<Value>> { + let mut values = Vec::new(); + + let get = |idx: u32| { + args.get(idx as usize) + .cloned() + .ok_or_else(|| format_err!("argument index out of bounds: {}", idx)) + }; + + for expr in bindings { + match expr { + ast::OutgoingBindingExpression::As(a) => { + let arg = get(a.idx)?; + match a.ty { + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::UnsignedLong) => match arg { + Val::I32(a) => values.push(Value::U32(a as u32)), + _ => bail!("can't convert {:?} to unsigned long", arg), + }, + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::Long) => match arg { + Val::I32(a) => values.push(Value::I32(a)), + _ => bail!("can't convert {:?} to long", arg), + }, + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::LongLong) => match arg { + Val::I32(a) => values.push(Value::I64(a as i64)), + Val::I64(a) => values.push(Value::I64(a)), + _ => bail!("can't convert {:?} to long long", arg), + }, + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::UnsignedLongLong) => { + match arg { + Val::I32(a) => values.push(Value::U64(a as u64)), + Val::I64(a) => values.push(Value::U64(a as u64)), + _ => bail!("can't convert {:?} to unsigned long long", arg), + } + } + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::Float) => match arg { + Val::F32(a) => values.push(Value::F32(f32::from_bits(a))), + _ => bail!("can't convert {:?} to float", arg), + }, + ast::WebidlTypeRef::Scalar(ast::WebidlScalarType::Double) => match arg { + Val::F32(a) => values.push(Value::F64(f32::from_bits(a) as f64)), + Val::F64(a) => values.push(Value::F64(f64::from_bits(a))), + _ => bail!("can't convert {:?} to double", arg), + }, + _ => bail!("unsupported outgoing binding expr {:?}", expr), + } + } + ast::OutgoingBindingExpression::Utf8Str(e) => { + if e.ty != ast::WebidlScalarType::DomString.into() { + bail!("utf-8 strings must go into dom-string") + } + let offset = match get(e.offset)? { + Val::I32(a) => a, + _ => bail!("offset must be an i32"), + }; + let length = match get(e.length)? { + Val::I32(a) => a, + _ => bail!("length must be an i32"), + }; + let bytes = unsafe { &cx.get_memory()?[offset as usize..][..length as usize] }; + values.push(Value::String(str::from_utf8(bytes).unwrap().to_string())); + } + _ => { + drop(cx); + bail!("unsupported outgoing binding expr {:?}", expr); + } + } + } + + Ok(values) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +
+use std::convert::TryFrom; +use std::fmt; + +/// The set of all possible WebAssembly Interface Types +#[derive(Debug, Clone)] +#[allow(missing_docs)] +pub enum Value { + String(String), + I32(i32), + U32(u32), + I64(i64), + U64(u64), + F32(f32), + F64(f64), +} + +macro_rules! from { + ($($a:ident => $b:ident,)*) => ($( + impl From<$a> for Value { + fn from(val: $a) -> Value { + Value::$b(val) + } + } + + impl TryFrom<Value> for $a { + type Error = anyhow::Error; + + fn try_from(val: Value) -> Result<$a, Self::Error> { + match val { + Value::$b(v) => Ok(v), + v => anyhow::bail!("cannot convert {:?} to {}", v, stringify!($a)), + } + } + } + )*) +} + +from! { + String => String, + i32 => I32, + u32 => U32, + i64 => I64, + u64 => U64, + f32 => F32, + f64 => F64, +} + +impl<'a> From<&'a str> for Value { + fn from(x: &'a str) -> Value { + x.to_string().into() + } +} + +impl fmt::Display for Value { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Value::String(s) => s.fmt(f), + Value::I32(s) => s.fmt(f), + Value::U32(s) => s.fmt(f), + Value::I64(s) => s.fmt(f), + Value::U64(s) => s.fmt(f), + Value::F32(s) => s.fmt(f), + Value::F64(s) => s.fmt(f), + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +
+//! Memory management for executable code. + +use crate::function_table::FunctionTable; +use region; +use std::mem::ManuallyDrop; +use std::{cmp, mem}; +use wasmtime_environ::{Compilation, CompiledFunction}; +use wasmtime_runtime::{Mmap, VMFunctionBody}; + +struct CodeMemoryEntry { + mmap: ManuallyDrop<Mmap>, + table: ManuallyDrop<FunctionTable>, +} + +impl CodeMemoryEntry { + fn new() -> Self { + Self { + mmap: ManuallyDrop::new(Mmap::new()), + table: ManuallyDrop::new(FunctionTable::new()), + } + } + fn with_capacity(cap: usize) -> Result<Self, String> { + Ok(Self { + mmap: ManuallyDrop::new(Mmap::with_at_least(cap)?), + table: ManuallyDrop::new(FunctionTable::new()), + }) + } +} + +impl Drop for CodeMemoryEntry { + fn drop(&mut self) { + unsafe { + // Table needs to be freed before mmap. + ManuallyDrop::drop(&mut self.table); + ManuallyDrop::drop(&mut self.mmap); + } + } +} + +/// Memory manager for executable code. +pub struct CodeMemory { + current: CodeMemoryEntry, + entries: Vec<CodeMemoryEntry>, + position: usize, + published: usize, +} + +fn _assert() { + fn _assert_send_sync<T: Send + Sync>() {} + _assert_send_sync::<CodeMemory>(); +} + +impl CodeMemory { + /// Create a new `CodeMemory` instance. + pub fn new() -> Self { + Self { + current: CodeMemoryEntry::new(), + entries: Vec::new(), + position: 0, + published: 0, + } + } + + /// Allocate a continuous memory block for a single compiled function. + /// TODO: Reorganize the code that calls this to emit code directly into the + /// mmap region rather than into a Vec that we need to copy in. + pub fn allocate_for_function( + &mut self, + func: &CompiledFunction, + ) -> Result<&mut [VMFunctionBody], String> { + let size = Self::function_allocation_size(func); + + let start = self.position as u32; + let (buf, table) = self.allocate(size)?; + + let (_, _, _, vmfunc) = Self::copy_function(func, start, buf, table); + + Ok(vmfunc) + } + + /// Allocate a continuous memory block for a compilation. + /// + /// Allocates memory for both the function bodies as well as function unwind data. + pub fn allocate_for_compilation( + &mut self, + compilation: &Compilation, + ) -> Result<Box<[&mut [VMFunctionBody]]>, String> { + let total_len = compilation + .into_iter() + .fold(0, |acc, func| acc + Self::function_allocation_size(func)); + + let mut start = self.position as u32; + let (mut buf, mut table) = self.allocate(total_len)?; + let mut result = Vec::with_capacity(compilation.len()); + + for func in compilation.into_iter() { + let (next_start, next_buf, next_table, vmfunc) = + Self::copy_function(func, start, buf, table); + + result.push(vmfunc); + + start = next_start; + buf = next_buf; + table = next_table; + } + + Ok(result.into_boxed_slice()) + } + + /// Make all allocated memory executable. + pub fn publish(&mut self) { + self.push_current(0) + .expect("failed to push current memory map"); + + for CodeMemoryEntry { mmap: m, table: t } in &mut self.entries[self.published..] { + // Remove write access to the pages due to the relocation fixups. + t.publish(m.as_ptr() as u64) + .expect("failed to publish function table"); + + if !m.is_empty() { + unsafe { + region::protect(m.as_mut_ptr(), m.len(), region::Protection::ReadExecute) + } + .expect("unable to make memory readonly and executable"); + } + } + + self.published = self.entries.len(); + } + + /// Allocate `size` bytes of memory which can be made executable later by + /// calling `publish()`. Note that we allocate the memory as writeable so + /// that it can be written to and patched, though we make it readonly before + /// actually executing from it. + /// + /// TODO: Add an alignment flag. + fn allocate(&mut self, size: usize) -> Result<(&mut [u8], &mut FunctionTable), String> { + if self.current.mmap.len() - self.position < size { + self.push_current(cmp::max(0x10000, size))?; + } + + let old_position = self.position; + self.position += size; + + Ok(( + &mut self.current.mmap.as_mut_slice()[old_position..self.position], + &mut self.current.table, + )) + } + + /// Calculates the allocation size of the given compiled function. + fn function_allocation_size(func: &CompiledFunction) -> usize { + if func.unwind_info.is_empty() { + func.body.len() + } else { + // Account for necessary unwind information alignment padding (32-bit) + ((func.body.len() + 3) & !3) + func.unwind_info.len() + } + } + + /// Copies the data of the compiled function to the given buffer. + /// + /// This will also add the function to the current function table. + fn copy_function<'a>( + func: &CompiledFunction, + func_start: u32, + buf: &'a mut [u8], + table: &'a mut FunctionTable, + ) -> ( + u32, + &'a mut [u8], + &'a mut FunctionTable, + &'a mut [VMFunctionBody], + ) { + let func_end = func_start + (func.body.len() as u32); + + let (body, remainder) = buf.split_at_mut(func.body.len()); + body.copy_from_slice(&func.body); + let vmfunc = Self::view_as_mut_vmfunc_slice(body); + + if func.unwind_info.is_empty() { + return (func_end, remainder, table, vmfunc); + } + + // Keep unwind information 32-bit aligned (round up to the nearest 4 byte boundary) + let padding = ((func.body.len() + 3) & !3) - func.body.len(); + let (unwind, remainder) = remainder.split_at_mut(padding + func.unwind_info.len()); + let mut relocs = Vec::new(); + func.unwind_info + .serialize(&mut unwind[padding..], &mut relocs); + + let unwind_start = func_end + (padding as u32); + let unwind_end = unwind_start + (func.unwind_info.len() as u32); + + relocs.iter_mut().for_each(move |r| { + r.offset += unwind_start; + r.addend += func_start; + }); + + table.add_function(func_start, func_end, unwind_start, &relocs); + + (unwind_end, remainder, table, vmfunc) + } + + /// Convert mut a slice from u8 to VMFunctionBody. + fn view_as_mut_vmfunc_slice(slice: &mut [u8]) -> &mut [VMFunctionBody] { + let byte_ptr: *mut [u8] = slice; + let body_ptr = byte_ptr as *mut [VMFunctionBody]; + unsafe { &mut *body_ptr } + } + + /// Pushes the current Mmap (and function table) and allocates a new Mmap of the given size. + fn push_current(&mut self, new_size: usize) -> Result<(), String> { + let previous = mem::replace( + &mut self.current, + if new_size == 0 { + CodeMemoryEntry::new() + } else { + CodeMemoryEntry::with_capacity(cmp::max(0x10000, new_size))? + }, + ); + + if !previous.mmap.is_empty() { + self.entries.push(previous); + } else { + assert_eq!(previous.table.len(), 0); + } + + self.position = 0; + + Ok(()) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +
+//! JIT compilation. + +use crate::code_memory::CodeMemory; +use crate::instantiate::SetupError; +use crate::target_tunables::target_tunables; +use cranelift_codegen::ir::InstBuilder; +use cranelift_codegen::print_errors::pretty_error; +use cranelift_codegen::Context; +use cranelift_codegen::{binemit, ir}; +use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext}; +use cranelift_wasm::ModuleTranslationState; +use std::collections::HashMap; +use std::convert::TryFrom; +use wasmtime_debug::{emit_debugsections_image, DebugInfoData}; +use wasmtime_environ::entity::{EntityRef, PrimaryMap}; +use wasmtime_environ::isa::{TargetFrontendConfig, TargetIsa}; +use wasmtime_environ::wasm::{DefinedFuncIndex, DefinedMemoryIndex, MemoryIndex}; +use wasmtime_environ::{ + CacheConfig, Compilation, CompileError, CompiledFunction, CompiledFunctionUnwindInfo, + Compiler as _C, FunctionBodyData, Module, ModuleMemoryOffset, ModuleVmctxInfo, Relocations, + Traps, Tunables, VMOffsets, +}; +use wasmtime_runtime::{ + InstantiationError, SignatureRegistry, TrapRegistration, TrapRegistry, VMFunctionBody, + VMSharedSignatureIndex, +}; + +/// Select which kind of compilation to use. +#[derive(Copy, Clone, Debug)] +pub enum CompilationStrategy { + /// Let Wasmtime pick the strategy. + Auto, + + /// Compile all functions with Cranelift. + Cranelift, + + /// Compile all functions with Lightbeam. + #[cfg(feature = "lightbeam")] + Lightbeam, +} + +/// A WebAssembly code JIT compiler. +/// +/// A `Compiler` instance owns the executable memory that it allocates. +/// +/// TODO: Evolve this to support streaming rather than requiring a `&[u8]` +/// containing a whole wasm module at once. +/// +/// TODO: Consider using cranelift-module. +pub struct Compiler { + isa: Box<dyn TargetIsa>, + + code_memory: CodeMemory, + trap_registry: TrapRegistry, + trampoline_park: HashMap<VMSharedSignatureIndex, *const VMFunctionBody>, + signatures: SignatureRegistry, + strategy: CompilationStrategy, + cache_config: CacheConfig, + + /// The `FunctionBuilderContext`, shared between trampline function compilations. + fn_builder_ctx: FunctionBuilderContext, +} + +impl Compiler { + /// Construct a new `Compiler`. + pub fn new( + isa: Box<dyn TargetIsa>, + strategy: CompilationStrategy, + cache_config: CacheConfig, + ) -> Self { + Self { + isa, + code_memory: CodeMemory::new(), + trampoline_park: HashMap::new(), + signatures: SignatureRegistry::new(), + fn_builder_ctx: FunctionBuilderContext::new(), + strategy, + trap_registry: TrapRegistry::default(), + cache_config, + } + } +} + +impl Compiler { + /// Return the target's frontend configuration settings. + pub fn frontend_config(&self) -> TargetFrontendConfig { + self.isa.frontend_config() + } + + /// Return the tunables in use by this engine. + pub fn tunables(&self) -> Tunables { + target_tunables(self.isa.triple()) + } + + /// Compile the given function bodies. + pub(crate) fn compile<'data>( + &mut self, + module: &Module, + module_translation: &ModuleTranslationState, + function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>, + debug_data: Option<DebugInfoData>, + ) -> Result< + ( + PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>, + PrimaryMap<DefinedFuncIndex, ir::JumpTableOffsets>, + Relocations, + Option<Vec<u8>>, + TrapRegistration, + ), + SetupError, + > { + let (compilation, relocations, address_transform, value_ranges, stack_slots, traps) = + match self.strategy { + // For now, interpret `Auto` as `Cranelift` since that's the most stable + // implementation. + CompilationStrategy::Auto | CompilationStrategy::Cranelift => { + wasmtime_environ::cranelift::Cranelift::compile_module( + module, + module_translation, + function_body_inputs, + &*self.isa, + debug_data.is_some(), + &self.cache_config, + ) + } + #[cfg(feature = "lightbeam")] + CompilationStrategy::Lightbeam => { + wasmtime_environ::lightbeam::Lightbeam::compile_module( + module, + module_translation, + function_body_inputs, + &*self.isa, + debug_data.is_some(), + &self.cache_config, + ) + } + } + .map_err(SetupError::Compile)?; + + let allocated_functions = + allocate_functions(&mut self.code_memory, &compilation).map_err(|message| { + SetupError::Instantiate(InstantiationError::Resource(format!( + "failed to allocate memory for functions: {}", + message + ))) + })?; + + let trap_registration = register_traps(&allocated_functions, &traps, &self.trap_registry); + + // Translate debug info (DWARF) only if at least one function is present. + let dbg = if debug_data.is_some() && !allocated_functions.is_empty() { + let target_config = self.isa.frontend_config(); + let ofs = VMOffsets::new(target_config.pointer_bytes(), &module); + + let mut funcs = Vec::new(); + for (i, allocated) in allocated_functions.into_iter() { + let ptr = (*allocated) as *const u8; + let body_len = compilation.get(i).body.len(); + funcs.push((ptr, body_len)); + } + let module_vmctx_info = { + ModuleVmctxInfo { + memory_offset: if ofs.num_imported_memories > 0 { + ModuleMemoryOffset::Imported(ofs.vmctx_vmmemory_import(MemoryIndex::new(0))) + } else if ofs.num_defined_memories > 0 { + ModuleMemoryOffset::Defined( + ofs.vmctx_vmmemory_definition_base(DefinedMemoryIndex::new(0)), + ) + } else { + ModuleMemoryOffset::None + }, + stack_slots, + } + }; + let bytes = emit_debugsections_image( + self.isa.triple().clone(), + target_config, + debug_data.as_ref().unwrap(), + &module_vmctx_info, + &address_transform, + &value_ranges, + &funcs, + ) + .map_err(SetupError::DebugInfo)?; + Some(bytes) + } else { + None + }; + + let jt_offsets = compilation.get_jt_offsets(); + + Ok(( + allocated_functions, + jt_offsets, + relocations, + dbg, + trap_registration, + )) + } + + /// Create a trampoline for invoking a function. + pub(crate) fn get_trampoline( + &mut self, + signature: &ir::Signature, + value_size: usize, + ) -> Result<*const VMFunctionBody, SetupError> { + let index = self.signatures.register(signature); + if let Some(trampoline) = self.trampoline_park.get(&index) { + return Ok(*trampoline); + } + let body = make_trampoline( + &*self.isa, + &mut self.code_memory, + &mut self.fn_builder_ctx, + signature, + value_size, + )?; + self.trampoline_park.insert(index, body); + return Ok(body); + } + + /// Create and publish a trampoline for invoking a function. + pub fn get_published_trampoline( + &mut self, + signature: &ir::Signature, + value_size: usize, + ) -> Result<*const VMFunctionBody, SetupError> { + let result = self.get_trampoline(signature, value_size)?; + self.publish_compiled_code(); + Ok(result) + } + + /// Make memory containing compiled code executable. + pub(crate) fn publish_compiled_code(&mut self) { + self.code_memory.publish(); + } + + /// Shared signature registry. + pub fn signatures(&self) -> &SignatureRegistry { + &self.signatures + } + + /// Shared registration of trap information + pub fn trap_registry(&self) -> &TrapRegistry { + &self.trap_registry + } +} + +/// Create a trampoline for invoking a function. +fn make_trampoline( + isa: &dyn TargetIsa, + code_memory: &mut CodeMemory, + fn_builder_ctx: &mut FunctionBuilderContext, + signature: &ir::Signature, + value_size: usize, +) -> Result<*const VMFunctionBody, SetupError> { + let pointer_type = isa.pointer_type(); + let mut wrapper_sig = ir::Signature::new(isa.frontend_config().default_call_conv); + + // Add the callee `vmctx` parameter. + wrapper_sig.params.push(ir::AbiParam::special( + pointer_type, + ir::ArgumentPurpose::VMContext, + )); + + // Add the caller `vmctx` parameter. + wrapper_sig.params.push(ir::AbiParam::new(pointer_type)); + + // Add the `callee_address` parameter. + wrapper_sig.params.push(ir::AbiParam::new(pointer_type)); + + // Add the `values_vec` parameter. + wrapper_sig.params.push(ir::AbiParam::new(pointer_type)); + + let mut context = Context::new(); + context.func = ir::Function::with_name_signature(ir::ExternalName::user(0, 0), wrapper_sig); + context.func.collect_frame_layout_info(); + + { + let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx); + let block0 = builder.create_block(); + + builder.append_block_params_for_function_params(block0); + builder.switch_to_block(block0); + builder.seal_block(block0); + + let (vmctx_ptr_val, caller_vmctx_ptr_val, callee_value, values_vec_ptr_val) = { + let params = builder.func.dfg.block_params(block0); + (params[0], params[1], params[2], params[3]) + }; + + // Load the argument values out of `values_vec`. + let mflags = ir::MemFlags::trusted(); + let callee_args = signature + .params + .iter() + .enumerate() + .map(|(i, r)| { + match i { + 0 => vmctx_ptr_val, + 1 => caller_vmctx_ptr_val, + _ => + // i - 2 because vmctx and caller vmctx aren't passed through `values_vec`. + { + builder.ins().load( + r.value_type, + mflags, + values_vec_ptr_val, + ((i - 2) * value_size) as i32, + ) + } + } + }) + .collect::<Vec<_>>(); + + let new_sig = builder.import_signature(signature.clone()); + + let call = builder + .ins() + .call_indirect(new_sig, callee_value, &callee_args); + + let results = builder.func.dfg.inst_results(call).to_vec(); + + // Store the return values into `values_vec`. + let mflags = ir::MemFlags::trusted(); + for (i, r) in results.iter().enumerate() { + builder + .ins() + .store(mflags, *r, values_vec_ptr_val, (i * value_size) as i32); + } + + builder.ins().return_(&[]); + builder.finalize() + } + + let mut code_buf = Vec::new(); + let mut reloc_sink = RelocSink {}; + let mut trap_sink = binemit::NullTrapSink {}; + let mut stackmap_sink = binemit::NullStackmapSink {}; + context + .compile_and_emit( + isa, + &mut code_buf, + &mut reloc_sink, + &mut trap_sink, + &mut stackmap_sink, + ) + .map_err(|error| { + SetupError::Compile(CompileError::Codegen(pretty_error( + &context.func, + Some(isa), + error, + ))) + })?; + + let unwind_info = CompiledFunctionUnwindInfo::new(isa, &context); + + Ok(code_memory + .allocate_for_function(&CompiledFunction { + body: code_buf, + jt_offsets: context.func.jt_offsets, + unwind_info, + }) + .map_err(|message| SetupError::Instantiate(InstantiationError::Resource(message)))? + .as_ptr()) +} + +fn allocate_functions( + code_memory: &mut CodeMemory, + compilation: &Compilation, +) -> Result<PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>, String> { + let fat_ptrs = code_memory.allocate_for_compilation(compilation)?; + + // Second, create a PrimaryMap from result vector of pointers. + let mut result = PrimaryMap::with_capacity(compilation.len()); + for i in 0..fat_ptrs.len() { + let fat_ptr: *mut [VMFunctionBody] = fat_ptrs[i]; + result.push(fat_ptr); + } + Ok(result) +} + +fn register_traps( + allocated_functions: &PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>, + traps: &Traps, + registry: &TrapRegistry, +) -> TrapRegistration { + let traps = + allocated_functions + .values() + .zip(traps.values()) + .flat_map(|(func_addr, func_traps)| { + func_traps.iter().map(move |trap_desc| { + let func_addr = *func_addr as *const u8 as usize; + let offset = usize::try_from(trap_desc.code_offset).unwrap(); + let trap_addr = func_addr + offset; + (trap_addr, trap_desc.source_loc, trap_desc.trap_code) + }) + }); + registry.register_traps(traps) +} + +/// We don't expect trampoline compilation to produce any relocations, so +/// this `RelocSink` just asserts that it doesn't recieve any. +struct RelocSink {} + +impl binemit::RelocSink for RelocSink { + fn reloc_block( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _block_offset: binemit::CodeOffset, + ) { + panic!("trampoline compilation should not produce block relocs"); + } + fn reloc_external( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _name: &ir::ExternalName, + _addend: binemit::Addend, + ) { + panic!("trampoline compilation should not produce external symbol relocs"); + } + fn reloc_constant( + &mut self, + _code_offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _constant_offset: ir::ConstantOffset, + ) { + panic!("trampoline compilation should not produce constant relocs"); + } + fn reloc_jt( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _jt: ir::JumpTable, + ) { + panic!("trampoline compilation should not produce jump table relocs"); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +
+//! Runtime function table. +//! +//! This module is primarily used to track JIT functions on Windows for stack walking and unwind. + +type FunctionTableReloc = wasmtime_environ::CompiledFunctionUnwindInfoReloc; + +/// Represents a runtime function table. +/// +/// This is used to register JIT code with the operating system to enable stack walking and unwinding. +#[cfg(all(target_os = "windows", target_arch = "x86_64"))] +pub(crate) struct FunctionTable { + functions: Vec<winapi::um::winnt::RUNTIME_FUNCTION>, + published: bool, +} + +#[cfg(all(target_os = "windows", target_arch = "x86_64"))] +impl FunctionTable { + /// Creates a new function table. + pub fn new() -> Self { + Self { + functions: Vec::new(), + published: false, + } + } + + /// Returns the number of functions in the table, also referred to as its 'length'. + pub fn len(&self) -> usize { + self.functions.len() + } + + /// Adds a function to the table based off of the start offset, end offset, and unwind offset. + /// + /// The offsets are from the "module base", which is provided when the table is published. + pub fn add_function( + &mut self, + start: u32, + end: u32, + unwind: u32, + _relocs: &[FunctionTableReloc], + ) { + assert_eq!(_relocs.len(), 0); + use winapi::um::winnt; + + assert!(!self.published, "table has already been published"); + + let mut entry = winnt::RUNTIME_FUNCTION::default(); + + entry.BeginAddress = start; + entry.EndAddress = end; + + unsafe { + *entry.u.UnwindInfoAddress_mut() = unwind; + } + + self.functions.push(entry); + } + + /// Publishes the function table using the given base address. + /// + /// A published function table will automatically be deleted when it is dropped. + pub fn publish(&mut self, base_address: u64) -> Result<(), String> { + use winapi::um::winnt; + + if self.published { + return Err("function table was already published".into()); + } + + self.published = true; + + if self.functions.is_empty() { + return Ok(()); + } + + unsafe { + // Windows heap allocations are 32-bit aligned, but assert just in case + assert_eq!( + (self.functions.as_mut_ptr() as u64) % 4, + 0, + "function table allocation was not aligned" + ); + + if winnt::RtlAddFunctionTable( + self.functions.as_mut_ptr(), + self.functions.len() as u32, + base_address, + ) == 0 + { + return Err("failed to add function table".into()); + } + } + + Ok(()) + } +} + +#[cfg(target_os = "windows")] +impl Drop for FunctionTable { + fn drop(&mut self) { + use winapi::um::winnt; + + if self.published { + unsafe { + winnt::RtlDeleteFunctionTable(self.functions.as_mut_ptr()); + } + } + } +} + +/// Represents a runtime function table. +/// +/// This is used to register JIT code with the operating system to enable stack walking and unwinding. +#[cfg(unix)] +pub(crate) struct FunctionTable { + functions: Vec<u32>, + relocs: Vec<FunctionTableReloc>, + published: Option<Vec<usize>>, +} + +#[cfg(unix)] +impl FunctionTable { + /// Creates a new function table. + pub fn new() -> Self { + Self { + functions: Vec::new(), + relocs: Vec::new(), + published: None, + } + } + + /// Returns the number of functions in the table, also referred to as its 'length'. + pub fn len(&self) -> usize { + self.functions.len() + } + + /// Adds a function to the table based off of the start offset, end offset, and unwind offset. + /// + /// The offsets are from the "module base", which is provided when the table is published. + pub fn add_function( + &mut self, + _start: u32, + _end: u32, + unwind: u32, + relocs: &[FunctionTableReloc], + ) { + assert!(self.published.is_none(), "table has already been published"); + self.functions.push(unwind); + self.relocs.extend_from_slice(relocs); + } + + /// Publishes the function table using the given base address. + /// + /// A published function table will automatically be deleted when it is dropped. + pub fn publish(&mut self, base_address: u64) -> Result<(), String> { + if self.published.is_some() { + return Err("function table was already published".into()); + } + + if self.functions.is_empty() { + assert_eq!(self.relocs.len(), 0); + self.published = Some(vec![]); + return Ok(()); + } + + extern "C" { + // libunwind import + fn __register_frame(fde: *const u8); + } + + for reloc in self.relocs.iter() { + let addr = base_address + (reloc.offset as u64); + let target = base_address + (reloc.addend as u64); + unsafe { + std::ptr::write(addr as *mut u64, target); + } + } + + let mut fdes = Vec::with_capacity(self.functions.len()); + for unwind_offset in self.functions.iter() { + let addr = base_address + (*unwind_offset as u64); + let off = unsafe { std::ptr::read::<u32>(addr as *const u32) } as usize + 4; + + let fde = (addr + off as u64) as usize; + unsafe { + __register_frame(fde as *const _); + } + fdes.push(fde); + } + + self.published = Some(fdes); + Ok(()) + } +} + +#[cfg(unix)] +impl Drop for FunctionTable { + fn drop(&mut self) { + extern "C" { + // libunwind import + fn __deregister_frame(fde: *const u8); + } + + if let Some(published) = &self.published { + unsafe { + // I'm not really sure why, but it appears to be way faster to + // unregister frames in reverse order rather than in-order. This + // way we're deregistering in LIFO order, and maybe there's some + // vec shifting or something like that in libgcc? + // + // Locally on Ubuntu 18.04 a wasm module with 40k empty + // functions takes 0.1s to compile and drop with reverse + // iteration. With forward iteration it takes 3s to compile and + // drop! + // + // Poking around libgcc sources seems to indicate that some sort + // of linked list is being traversed... We may need to figure + // out something else for backtraces in the future since this + // API may not be long-lived to keep calling. + for fde in published.iter().rev() { + __deregister_frame(*fde as *const _); + } + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +
+//! Module imports resolving logic. + +use crate::resolver::Resolver; +use more_asserts::assert_ge; +use std::collections::HashSet; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::wasm::{Global, GlobalInit, Memory, Table, TableElementType}; +use wasmtime_environ::{MemoryPlan, MemoryStyle, Module, TablePlan}; +use wasmtime_runtime::{ + Export, Imports, InstanceHandle, LinkError, VMFunctionImport, VMGlobalImport, VMMemoryImport, + VMTableImport, +}; + +/// This function allows to match all imports of a `Module` with concrete definitions provided by +/// a `Resolver`. +/// +/// If all imports are satisfied returns an `Imports` instance required for a module instantiation. +pub fn resolve_imports(module: &Module, resolver: &mut dyn Resolver) -> Result<Imports, LinkError> { + let mut dependencies = HashSet::new(); + + let mut function_imports = PrimaryMap::with_capacity(module.imported_funcs.len()); + for (index, (module_name, field, import_idx)) in module.imported_funcs.iter() { + match resolver.resolve(*import_idx, module_name, field) { + Some(export_value) => match export_value { + Export::Function { + address, + signature, + vmctx, + } => { + let import_signature = &module.signatures[module.functions[index]]; + if signature != *import_signature { + // TODO: If the difference is in the calling convention, + // we could emit a wrapper function to fix it up. + return Err(LinkError(format!( + "{}/{}: incompatible import type: exported function with signature {} \ + incompatible with function import with signature {}", + module_name, field, signature, import_signature + ))); + } + dependencies.insert(unsafe { InstanceHandle::from_vmctx(vmctx) }); + function_imports.push(VMFunctionImport { + body: address, + vmctx, + }); + } + Export::Table { .. } | Export::Memory { .. } | Export::Global { .. } => { + return Err(LinkError(format!( + "{}/{}: incompatible import type: export incompatible with function import", + module_name, field + ))); + } + }, + None => { + return Err(LinkError(format!( + "{}/{}: unknown import function: function not provided", + module_name, field + ))); + } + } + } + + let mut table_imports = PrimaryMap::with_capacity(module.imported_tables.len()); + for (index, (module_name, field, import_idx)) in module.imported_tables.iter() { + match resolver.resolve(*import_idx, module_name, field) { + Some(export_value) => match export_value { + Export::Table { + definition, + vmctx, + table, + } => { + let import_table = &module.table_plans[index]; + if !is_table_compatible(&table, import_table) { + return Err(LinkError(format!( + "{}/{}: incompatible import type: exported table incompatible with \ + table import", + module_name, field, + ))); + } + dependencies.insert(unsafe { InstanceHandle::from_vmctx(vmctx) }); + table_imports.push(VMTableImport { + from: definition, + vmctx, + }); + } + Export::Global { .. } | Export::Memory { .. } | Export::Function { .. } => { + return Err(LinkError(format!( + "{}/{}: incompatible import type: export incompatible with table import", + module_name, field + ))); + } + }, + None => { + return Err(LinkError(format!( + "unknown import: no provided import table for {}/{}", + module_name, field + ))); + } + } + } + + let mut memory_imports = PrimaryMap::with_capacity(module.imported_memories.len()); + for (index, (module_name, field, import_idx)) in module.imported_memories.iter() { + match resolver.resolve(*import_idx, module_name, field) { + Some(export_value) => match export_value { + Export::Memory { + definition, + vmctx, + memory, + } => { + let import_memory = &module.memory_plans[index]; + if !is_memory_compatible(&memory, import_memory) { + return Err(LinkError(format!( + "{}/{}: incompatible import type: exported memory incompatible with \ + memory import", + module_name, field + ))); + } + + // Sanity-check: Ensure that the imported memory has at least + // guard-page protections the importing module expects it to have. + if let ( + MemoryStyle::Static { bound }, + MemoryStyle::Static { + bound: import_bound, + }, + ) = (memory.style, &import_memory.style) + { + assert_ge!(bound, *import_bound); + } + assert_ge!(memory.offset_guard_size, import_memory.offset_guard_size); + + dependencies.insert(unsafe { InstanceHandle::from_vmctx(vmctx) }); + memory_imports.push(VMMemoryImport { + from: definition, + vmctx, + }); + } + Export::Table { .. } | Export::Global { .. } | Export::Function { .. } => { + return Err(LinkError(format!( + "{}/{}: incompatible import type: export incompatible with memory import", + module_name, field + ))); + } + }, + None => { + return Err(LinkError(format!( + "unknown import: no provided import memory for {}/{}", + module_name, field + ))); + } + } + } + + let mut global_imports = PrimaryMap::with_capacity(module.imported_globals.len()); + for (index, (module_name, field, import_idx)) in module.imported_globals.iter() { + match resolver.resolve(*import_idx, module_name, field) { + Some(export_value) => match export_value { + Export::Table { .. } | Export::Memory { .. } | Export::Function { .. } => { + return Err(LinkError(format!( + "{}/{}: incompatible import type: exported global incompatible with \ + global import", + module_name, field + ))); + } + Export::Global { + definition, + vmctx, + global, + } => { + let imported_global = module.globals[index]; + if !is_global_compatible(&global, &imported_global) { + return Err(LinkError(format!( + "{}/{}: incompatible import type: exported global incompatible with \ + global import", + module_name, field + ))); + } + dependencies.insert(unsafe { InstanceHandle::from_vmctx(vmctx) }); + global_imports.push(VMGlobalImport { from: definition }); + } + }, + None => { + return Err(LinkError(format!( + "unknown import: no provided import global for {}/{}", + module_name, field + ))); + } + } + } + + Ok(Imports::new( + dependencies, + function_imports, + table_imports, + memory_imports, + global_imports, + )) +} + +fn is_global_compatible(exported: &Global, imported: &Global) -> bool { + match imported.initializer { + GlobalInit::Import => (), + _ => panic!("imported Global should have an Imported initializer"), + } + + let Global { + ty: exported_ty, + mutability: exported_mutability, + initializer: _exported_initializer, + } = exported; + let Global { + ty: imported_ty, + mutability: imported_mutability, + initializer: _imported_initializer, + } = imported; + exported_ty == imported_ty && imported_mutability == exported_mutability +} + +fn is_table_element_type_compatible( + exported_type: TableElementType, + imported_type: TableElementType, +) -> bool { + match exported_type { + TableElementType::Func => match imported_type { + TableElementType::Func => true, + _ => false, + }, + TableElementType::Val(exported_val_ty) => match imported_type { + TableElementType::Val(imported_val_ty) => exported_val_ty == imported_val_ty, + _ => false, + }, + } +} + +fn is_table_compatible(exported: &TablePlan, imported: &TablePlan) -> bool { + let TablePlan { + table: + Table { + ty: exported_ty, + minimum: exported_minimum, + maximum: exported_maximum, + }, + style: _exported_style, + } = exported; + let TablePlan { + table: + Table { + ty: imported_ty, + minimum: imported_minimum, + maximum: imported_maximum, + }, + style: _imported_style, + } = imported; + + is_table_element_type_compatible(*exported_ty, *imported_ty) + && imported_minimum <= exported_minimum + && (imported_maximum.is_none() + || (!exported_maximum.is_none() + && imported_maximum.unwrap() >= exported_maximum.unwrap())) +} + +fn is_memory_compatible(exported: &MemoryPlan, imported: &MemoryPlan) -> bool { + let MemoryPlan { + memory: + Memory { + minimum: exported_minimum, + maximum: exported_maximum, + shared: exported_shared, + }, + style: _exported_style, + offset_guard_size: _exported_offset_guard_size, + } = exported; + let MemoryPlan { + memory: + Memory { + minimum: imported_minimum, + maximum: imported_maximum, + shared: imported_shared, + }, + style: _imported_style, + offset_guard_size: _imported_offset_guard_size, + } = imported; + + imported_minimum <= exported_minimum + && (imported_maximum.is_none() + || (!exported_maximum.is_none() + && imported_maximum.unwrap() >= exported_maximum.unwrap())) + && exported_shared == imported_shared +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +
+//! Define the `instantiate` function, which takes a byte array containing an +//! encoded wasm module and returns a live wasm instance. Also, define +//! `CompiledModule` to allow compiling and instantiating to be done as separate +//! steps. + +use crate::compiler::Compiler; +use crate::imports::resolve_imports; +use crate::link::link_module; +use crate::resolver::Resolver; +use std::io::Write; +use std::rc::Rc; +use std::sync::Arc; +use thiserror::Error; +use wasmtime_debug::read_debuginfo; +use wasmtime_environ::entity::{BoxedSlice, PrimaryMap}; +use wasmtime_environ::wasm::{DefinedFuncIndex, SignatureIndex}; +use wasmtime_environ::{ + CompileError, DataInitializer, DataInitializerLocation, Module, ModuleEnvironment, +}; +use wasmtime_runtime::{ + GdbJitImageRegistration, InstanceHandle, InstantiationError, TrapRegistration, VMFunctionBody, + VMSharedSignatureIndex, +}; + +/// An error condition while setting up a wasm instance, be it validation, +/// compilation, or instantiation. +#[derive(Error, Debug)] +pub enum SetupError { + /// The module did not pass validation. + #[error("Validation error: {0}")] + Validate(String), + + /// A wasm translation error occured. + #[error("WebAssembly failed to compile")] + Compile(#[from] CompileError), + + /// Some runtime resource was unavailable or insufficient, or the start function + /// trapped. + #[error("Instantiation failed during setup")] + Instantiate(#[from] InstantiationError), + + /// Debug information generation error occured. + #[error("Debug information error")] + DebugInfo(#[from] anyhow::Error), +} + +/// This is similar to `CompiledModule`, but references the data initializers +/// from the wasm buffer rather than holding its own copy. +struct RawCompiledModule<'data> { + module: Module, + finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>, + data_initializers: Box<[DataInitializer<'data>]>, + signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>, + dbg_jit_registration: Option<GdbJitImageRegistration>, + trap_registration: TrapRegistration, +} + +impl<'data> RawCompiledModule<'data> { + /// Create a new `RawCompiledModule` by compiling the wasm module in `data` and instatiating it. + fn new( + compiler: &mut Compiler, + data: &'data [u8], + debug_info: bool, + ) -> Result<Self, SetupError> { + let environ = ModuleEnvironment::new(compiler.frontend_config(), compiler.tunables()); + + let translation = environ + .translate(data) + .map_err(|error| SetupError::Compile(CompileError::Wasm(error)))?; + + let debug_data = if debug_info { + Some(read_debuginfo(&data)) + } else { + None + }; + + let (finished_functions, jt_offsets, relocations, dbg_image, trap_registration) = compiler + .compile( + &translation.module, + translation.module_translation.as_ref().unwrap(), + translation.function_body_inputs, + debug_data, + )?; + + link_module( + &translation.module, + &finished_functions, + &jt_offsets, + relocations, + ); + + // Compute indices into the shared signature table. + let signatures = { + let signature_registry = compiler.signatures(); + translation + .module + .signatures + .values() + .map(|sig| signature_registry.register(sig)) + .collect::<PrimaryMap<_, _>>() + }; + + // Make all code compiled thus far executable. + compiler.publish_compiled_code(); + + let dbg_jit_registration = if let Some(img) = dbg_image { + let mut bytes = Vec::new(); + bytes.write_all(&img).expect("all written"); + let reg = GdbJitImageRegistration::register(bytes); + Some(reg) + } else { + None + }; + + Ok(Self { + module: translation.module, + finished_functions: finished_functions.into_boxed_slice(), + data_initializers: translation.data_initializers.into_boxed_slice(), + signatures: signatures.into_boxed_slice(), + dbg_jit_registration, + trap_registration, + }) + } +} + +/// A compiled wasm module, ready to be instantiated. +pub struct CompiledModule { + module: Arc<Module>, + finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>, + data_initializers: Box<[OwnedDataInitializer]>, + signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>, + dbg_jit_registration: Option<Rc<GdbJitImageRegistration>>, + trap_registration: TrapRegistration, +} + +impl CompiledModule { + /// Compile a data buffer into a `CompiledModule`, which may then be instantiated. + pub fn new<'data>( + compiler: &mut Compiler, + data: &'data [u8], + debug_info: bool, + ) -> Result<Self, SetupError> { + let raw = RawCompiledModule::<'data>::new(compiler, data, debug_info)?; + + Ok(Self::from_parts( + raw.module, + raw.finished_functions, + raw.data_initializers + .iter() + .map(OwnedDataInitializer::new) + .collect::<Vec<_>>() + .into_boxed_slice(), + raw.signatures.clone(), + raw.dbg_jit_registration, + raw.trap_registration, + )) + } + + /// Construct a `CompiledModule` from component parts. + pub fn from_parts( + module: Module, + finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>, + data_initializers: Box<[OwnedDataInitializer]>, + signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>, + dbg_jit_registration: Option<GdbJitImageRegistration>, + trap_registration: TrapRegistration, + ) -> Self { + Self { + module: Arc::new(module), + finished_functions, + data_initializers, + signatures, + dbg_jit_registration: dbg_jit_registration.map(Rc::new), + trap_registration, + } + } + + /// Crate an `Instance` from this `CompiledModule`. + /// + /// Note that if only one instance of this module is needed, it may be more + /// efficient to call the top-level `instantiate`, since that avoids copying + /// the data initializers. + /// + /// # Unsafety + /// + /// See `InstanceHandle::new` + pub unsafe fn instantiate( + &self, + resolver: &mut dyn Resolver, + ) -> Result<InstanceHandle, InstantiationError> { + let data_initializers = self + .data_initializers + .iter() + .map(|init| DataInitializer { + location: init.location.clone(), + data: &*init.data, + }) + .collect::<Vec<_>>(); + let imports = resolve_imports(&self.module, resolver)?; + InstanceHandle::new( + Arc::clone(&self.module), + self.trap_registration.clone(), + self.finished_functions.clone(), + imports, + &data_initializers, + self.signatures.clone(), + self.dbg_jit_registration.as_ref().map(|r| Rc::clone(&r)), + Box::new(()), + ) + } + + /// Return a reference-counting pointer to a module. + pub fn module(&self) -> &Arc<Module> { + &self.module + } + + /// Return a reference to a module. + pub fn module_ref(&self) -> &Module { + &self.module + } + + /// Returns the map of all finished JIT functions compiled for this module + pub fn finished_functions(&self) -> &BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]> { + &self.finished_functions + } +} + +/// Similar to `DataInitializer`, but owns its own copy of the data rather +/// than holding a slice of the original module. +pub struct OwnedDataInitializer { + /// The location where the initialization is to be performed. + location: DataInitializerLocation, + + /// The initialization data. + data: Box<[u8]>, +} + +impl OwnedDataInitializer { + fn new(borrowed: &DataInitializer<'_>) -> Self { + Self { + location: borrowed.location.clone(), + data: borrowed.data.to_vec().into_boxed_slice(), + } + } +} + +/// Create a new wasm instance by compiling the wasm module in `data` and instatiating it. +/// +/// This is equivalent to createing a `CompiledModule` and calling `instantiate()` on it, +/// but avoids creating an intermediate copy of the data initializers. +/// +/// # Unsafety +/// +/// See `InstanceHandle::new` +#[allow(clippy::implicit_hasher)] +pub unsafe fn instantiate( + compiler: &mut Compiler, + data: &[u8], + resolver: &mut dyn Resolver, + debug_info: bool, +) -> Result<InstanceHandle, SetupError> { + let instance = CompiledModule::new(compiler, data, debug_info)?.instantiate(resolver)?; + Ok(instance) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +
+//! JIT-style runtime for WebAssembly using Cranelift. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod code_memory; +mod compiler; +mod function_table; +mod imports; +mod instantiate; +mod link; +mod resolver; +mod target_tunables; + +pub mod native; +pub mod trampoline; + +pub use crate::code_memory::CodeMemory; +pub use crate::compiler::{CompilationStrategy, Compiler}; +pub use crate::instantiate::{instantiate, CompiledModule, SetupError}; +pub use crate::link::link_module; +pub use crate::resolver::{NullResolver, Resolver}; +pub use crate::target_tunables::target_tunables; + +// Re-export `InstanceHandle` so that users won't need to separately depend on +// wasmtime-runtime in common cases. +pub use wasmtime_runtime::{InstanceHandle, InstantiationError}; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +
+//! Linking for JIT-compiled code. + +use cranelift_codegen::binemit::Reloc; +use cranelift_codegen::ir::JumpTableOffsets; +use std::ptr::write_unaligned; +use wasmtime_environ::entity::PrimaryMap; +use wasmtime_environ::wasm::DefinedFuncIndex; +use wasmtime_environ::{Module, RelocationTarget, Relocations}; +use wasmtime_runtime::libcalls; +use wasmtime_runtime::VMFunctionBody; + +/// Links a module that has been compiled with `compiled_module` in `wasmtime-environ`. +/// +/// Performs all required relocations inside the function code, provided the necessary metadata. +pub fn link_module( + module: &Module, + allocated_functions: &PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>, + jt_offsets: &PrimaryMap<DefinedFuncIndex, JumpTableOffsets>, + relocations: Relocations, +) { + for (i, function_relocs) in relocations.into_iter() { + for r in function_relocs { + use self::libcalls::*; + let target_func_address: usize = match r.reloc_target { + RelocationTarget::UserFunc(index) => match module.defined_func_index(index) { + Some(f) => { + let fatptr: *const [VMFunctionBody] = allocated_functions[f]; + fatptr as *const VMFunctionBody as usize + } + None => panic!("direct call to import"), + }, + RelocationTarget::LibCall(libcall) => { + use cranelift_codegen::ir::LibCall::*; + match libcall { + CeilF32 => wasmtime_f32_ceil as usize, + FloorF32 => wasmtime_f32_floor as usize, + TruncF32 => wasmtime_f32_trunc as usize, + NearestF32 => wasmtime_f32_nearest as usize, + CeilF64 => wasmtime_f64_ceil as usize, + FloorF64 => wasmtime_f64_floor as usize, + TruncF64 => wasmtime_f64_trunc as usize, + NearestF64 => wasmtime_f64_nearest as usize, + Probestack => PROBESTACK as usize, + other => panic!("unexpected libcall: {}", other), + } + } + RelocationTarget::JumpTable(func_index, jt) => { + match module.defined_func_index(func_index) { + Some(f) => { + let offset = *jt_offsets + .get(f) + .and_then(|ofs| ofs.get(jt)) + .expect("func jump table"); + let fatptr: *const [VMFunctionBody] = allocated_functions[f]; + fatptr as *const VMFunctionBody as usize + offset as usize + } + None => panic!("func index of jump table"), + } + } + }; + + let fatptr: *const [VMFunctionBody] = allocated_functions[i]; + let body = fatptr as *const VMFunctionBody; + match r.reloc { + #[cfg(target_pointer_width = "64")] + Reloc::Abs8 => unsafe { + let reloc_address = body.add(r.offset as usize) as usize; + let reloc_addend = r.addend as isize; + let reloc_abs = (target_func_address as u64) + .checked_add(reloc_addend as u64) + .unwrap(); + write_unaligned(reloc_address as *mut u64, reloc_abs); + }, + #[cfg(target_pointer_width = "32")] + Reloc::X86PCRel4 => unsafe { + let reloc_address = body.add(r.offset as usize) as usize; + let reloc_addend = r.addend as isize; + let reloc_delta_u32 = (target_func_address as u32) + .wrapping_sub(reloc_address as u32) + .checked_add(reloc_addend as u32) + .unwrap(); + write_unaligned(reloc_address as *mut u32, reloc_delta_u32); + }, + #[cfg(target_pointer_width = "32")] + Reloc::X86CallPCRel4 => { + // ignore + } + Reloc::X86PCRelRodata4 => { + // ignore + } + _ => panic!("unsupported reloc kind"), + } + } + } +} + +// A declaration for the stack probe function in Rust's standard library, for +// catching callstack overflow. +cfg_if::cfg_if! { + if #[cfg(any( + target_arch="aarch64", + all( + target_os = "windows", + target_env = "msvc", + target_pointer_width = "64" + ) + ))] { + extern "C" { + pub fn __chkstk(); + } + const PROBESTACK: unsafe extern "C" fn() = __chkstk; + } else if #[cfg(all(target_os = "windows", target_env = "gnu"))] { + extern "C" { + // ___chkstk (note the triple underscore) is implemented in compiler-builtins/src/x86_64.rs + // by the Rust compiler for the MinGW target + #[cfg(all(target_os = "windows", target_env = "gnu"))] + pub fn ___chkstk(); + } + const PROBESTACK: unsafe extern "C" fn() = ___chkstk; + } else { + extern "C" { + pub fn __rust_probestack(); + } + static PROBESTACK: unsafe extern "C" fn() = __rust_probestack; + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +
+#![allow(missing_docs)] + +use cranelift_codegen; + +pub fn builder() -> cranelift_codegen::isa::Builder { + cranelift_native::builder().expect("host machine is not a supported target") +} + +pub fn call_conv() -> cranelift_codegen::isa::CallConv { + use target_lexicon::HOST; + cranelift_codegen::isa::CallConv::triple_default(&HOST) +} + +pub use cranelift_codegen::isa::lookup; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +
+//! Define the `Resolver` trait, allowing custom resolution for external +//! references. + +use wasmtime_runtime::Export; + +/// Import resolver connects imports with available exported values. +pub trait Resolver { + /// Resolves an import a WebAssembly module to an export it's hooked up to. + /// + /// The `index` provided is the index of the import in the wasm module + /// that's being resolved. For example 1 means that it's the second import + /// listed in the wasm module. + /// + /// The `module` and `field` arguments provided are the module/field names + /// listed on the import itself. + fn resolve(&mut self, index: u32, module: &str, field: &str) -> Option<Export>; +} + +/// `Resolver` implementation that always resolves to `None`. +pub struct NullResolver {} + +impl Resolver for NullResolver { + fn resolve(&mut self, _idx: u32, _module: &str, _field: &str) -> Option<Export> { + None + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +
+use std::cmp::min; +use target_lexicon::{OperatingSystem, Triple}; +use wasmtime_environ::Tunables; + +/// Return a `Tunables` instance tuned for the given target platform. +pub fn target_tunables(triple: &Triple) -> Tunables { + let mut result = Tunables::default(); + + match triple.operating_system { + OperatingSystem::Windows => { + // For now, use a smaller footprint on Windows so that we don't + // don't outstrip the paging file. + // TODO: Make this configurable. + result.static_memory_bound = min(result.static_memory_bound, 0x100); + result.static_memory_offset_guard_size = + min(result.static_memory_offset_guard_size, 0x10000); + } + _ => {} + } + + result +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +
+#![allow(missing_docs)] + +pub mod ir { + pub use cranelift_codegen::ir::{ + ExternalName, Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, + }; +} +pub use cranelift_codegen::print_errors::pretty_error; +pub use cranelift_codegen::Context; +pub use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext}; + +pub mod binemit { + pub use cranelift_codegen::binemit::NullTrapSink; + pub use cranelift_codegen::binemit::{CodeOffset, NullStackmapSink, TrapSink}; + + use cranelift_codegen::{binemit, ir}; + + /// We don't expect trampoline compilation to produce any relocations, so + /// this `RelocSink` just asserts that it doesn't recieve any. + pub struct TrampolineRelocSink {} + + impl binemit::RelocSink for TrampolineRelocSink { + fn reloc_block( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _block_offset: binemit::CodeOffset, + ) { + panic!("trampoline compilation should not produce block relocs"); + } + fn reloc_external( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _name: &ir::ExternalName, + _addend: binemit::Addend, + ) { + panic!("trampoline compilation should not produce external symbol relocs"); + } + fn reloc_constant( + &mut self, + _code_offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _constant_offset: ir::ConstantOffset, + ) { + panic!("trampoline compilation should not produce constant relocs"); + } + fn reloc_jt( + &mut self, + _offset: binemit::CodeOffset, + _reloc: binemit::Reloc, + _jt: ir::JumpTable, + ) { + panic!("trampoline compilation should not produce jump table relocs"); + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +
+#![allow(clippy::cast_ptr_alignment)] + +use more_asserts::assert_le; +use std::collections::hash_map::Entry; +use std::collections::HashMap; +use std::ptr; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::isa::TargetFrontendConfig; +use wasmtime_environ::wasm::GlobalInit; +use wasmtime_environ::{Module, TargetSharedSignatureIndex, VMOffsets}; + +pub struct TableRelocation { + pub index: usize, + pub offset: usize, +} + +pub fn layout_vmcontext( + module: &Module, + target_config: &TargetFrontendConfig, +) -> (Box<[u8]>, Box<[TableRelocation]>) { + let ofs = VMOffsets::new(target_config.pointer_bytes(), &module); + let out_len = ofs.size_of_vmctx() as usize; + let mut out = vec![0; out_len]; + + // Assign unique indicies to unique signatures. + let mut signature_registry = HashMap::new(); + let mut signature_registry_len = signature_registry.len(); + for (index, sig) in module.signatures.iter() { + let offset = ofs.vmctx_vmshared_signature_id(index) as usize; + let target_index = match signature_registry.entry(sig) { + Entry::Occupied(o) => *o.get(), + Entry::Vacant(v) => { + assert_le!(signature_registry_len, std::u32::MAX as usize); + let id = TargetSharedSignatureIndex::new(signature_registry_len as u32); + signature_registry_len += 1; + *v.insert(id) + } + }; + unsafe { + let to = out.as_mut_ptr().add(offset) as *mut TargetSharedSignatureIndex; + ptr::write(to, target_index); + } + } + + let num_tables_imports = module.imported_tables.len(); + let mut table_relocs = Vec::with_capacity(module.table_plans.len() - num_tables_imports); + for (index, table) in module.table_plans.iter().skip(num_tables_imports) { + let def_index = module.defined_table_index(index).unwrap(); + let offset = ofs.vmctx_vmtable_definition(def_index) as usize; + let current_elements = table.table.minimum; + unsafe { + assert_eq!( + ::std::mem::size_of::<u32>() as u8, + ofs.size_of_vmtable_definition_current_elements(), + "vmtable_definition_current_elements expected to be u32" + ); + let to = out + .as_mut_ptr() + .add(offset) + .add(ofs.vmtable_definition_current_elements() as usize); + ptr::write(to as *mut u32, current_elements); + } + table_relocs.push(TableRelocation { + index: def_index.index(), + offset, + }); + } + + let num_globals_imports = module.imported_globals.len(); + for (index, global) in module.globals.iter().skip(num_globals_imports) { + let def_index = module.defined_global_index(index).unwrap(); + let offset = ofs.vmctx_vmglobal_definition(def_index) as usize; + let to = unsafe { out.as_mut_ptr().add(offset) }; + match global.initializer { + GlobalInit::I32Const(x) => unsafe { + ptr::write(to as *mut i32, x); + }, + GlobalInit::I64Const(x) => unsafe { + ptr::write(to as *mut i64, x); + }, + GlobalInit::F32Const(x) => unsafe { + ptr::write(to as *mut u32, x); + }, + GlobalInit::F64Const(x) => unsafe { + ptr::write(to as *mut u64, x); + }, + _ => panic!("unsupported global type"), + } + } + + (out.into_boxed_slice(), table_relocs.into_boxed_slice()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +
+use anyhow::Result; +use faerie::{Artifact, Decl}; +use wasmtime_environ::DataInitializer; + +/// Declares data segment symbol +pub fn declare_data_segment( + obj: &mut Artifact, + _data_initaliazer: &DataInitializer, + index: usize, +) -> Result<()> { + let name = format!("_memory_{}", index); + obj.declare(name, Decl::data())?; + Ok(()) +} + +/// Emit segment data and initialization location +pub fn emit_data_segment( + obj: &mut Artifact, + data_initaliazer: &DataInitializer, + index: usize, +) -> Result<()> { + let name = format!("_memory_{}", index); + obj.define(name, Vec::from(data_initaliazer.data))?; + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +
+use anyhow::Result; +use faerie::{Artifact, Decl, Link}; +use wasmtime_environ::entity::EntityRef; +use wasmtime_environ::settings; +use wasmtime_environ::settings::Configurable; +use wasmtime_environ::{Compilation, Module, RelocationTarget, Relocations}; + +/// Defines module functions +pub fn declare_functions( + obj: &mut Artifact, + module: &Module, + relocations: &Relocations, +) -> Result<()> { + for i in 0..module.imported_funcs.len() { + let string_name = format!("_wasm_function_{}", i); + obj.declare(string_name, Decl::function_import())?; + } + for (i, _function_relocs) in relocations.iter().rev() { + let func_index = module.func_index(i); + let string_name = format!("_wasm_function_{}", func_index.index()); + obj.declare(string_name, Decl::function().global())?; + } + Ok(()) +} + +/// Emits module functions +pub fn emit_functions( + obj: &mut Artifact, + module: &Module, + compilation: &Compilation, + relocations: &Relocations, +) -> Result<()> { + debug_assert!( + module.start_func.is_none() + || module.start_func.unwrap().index() >= module.imported_funcs.len(), + "imported start functions not supported yet" + ); + + let mut shared_builder = settings::builder(); + shared_builder + .enable("enable_verifier") + .expect("Missing enable_verifier setting"); + + for (i, _function_relocs) in relocations.iter() { + let body = &compilation.get(i).body; + let func_index = module.func_index(i); + let string_name = format!("_wasm_function_{}", func_index.index()); + + obj.define(string_name, body.clone())?; + } + + for (i, function_relocs) in relocations.iter() { + let func_index = module.func_index(i); + let string_name = format!("_wasm_function_{}", func_index.index()); + for r in function_relocs { + debug_assert_eq!(r.addend, 0); + match r.reloc_target { + RelocationTarget::UserFunc(target_index) => { + let target_name = format!("_wasm_function_{}", target_index.index()); + obj.link(Link { + from: &string_name, + to: &target_name, + at: r.offset as u64, + })?; + } + RelocationTarget::JumpTable(_, _) => { + // ignore relocations for jump tables + } + _ => panic!("relocations target not supported yet: {:?}", r.reloc_target), + }; + } + } + + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +
+//! Object-file writing library using the wasmtime environment. + +#![deny( + missing_docs, + trivial_numeric_casts, + unused_extern_crates, + unstable_features +)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod context; +mod data_segment; +mod function; +mod module; +mod table; + +pub use crate::module::emit_module; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +
+use crate::context::layout_vmcontext; +use crate::data_segment::{declare_data_segment, emit_data_segment}; +use crate::function::{declare_functions, emit_functions}; +use crate::table::{declare_table, emit_table}; +use anyhow::Result; +use faerie::{Artifact, Decl, Link}; +use wasmtime_environ::isa::TargetFrontendConfig; +use wasmtime_environ::{Compilation, DataInitializer, Module, Relocations}; + +fn emit_vmcontext_init( + obj: &mut Artifact, + module: &Module, + target_config: &TargetFrontendConfig, +) -> Result<()> { + let (data, table_relocs) = layout_vmcontext(module, target_config); + obj.declare_with("_vmcontext_init", Decl::data().global(), data.to_vec())?; + for reloc in table_relocs.iter() { + let target_name = format!("_table_{}", reloc.index); + obj.link(Link { + from: "_vmcontext_init", + to: &target_name, + at: reloc.offset as u64, + })?; + } + Ok(()) +} + +/// Emits a module that has been emitted with the `wasmtime-environ` environment +/// implementation to a native object file. +pub fn emit_module( + obj: &mut Artifact, + module: &Module, + compilation: &Compilation, + relocations: &Relocations, + data_initializers: &[DataInitializer], + target_config: &TargetFrontendConfig, +) -> Result<()> { + declare_functions(obj, module, relocations)?; + + for (i, initializer) in data_initializers.iter().enumerate() { + declare_data_segment(obj, initializer, i)?; + } + + for i in 0..module.table_plans.len() { + declare_table(obj, i)?; + } + + emit_functions(obj, module, compilation, relocations)?; + + for (i, initializer) in data_initializers.iter().enumerate() { + emit_data_segment(obj, initializer, i)?; + } + + for i in 0..module.table_plans.len() { + emit_table(obj, i)?; + } + + emit_vmcontext_init(obj, module, target_config)?; + + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +
+use anyhow::Result; +use faerie::{Artifact, Decl}; + +/// Declares data segment symbol +pub fn declare_table(obj: &mut Artifact, index: usize) -> Result<()> { + let name = format!("_table_{}", index); + obj.declare(name, Decl::data())?; + Ok(()) +} + +/// Emit segment data and initialization location +pub fn emit_table(obj: &mut Artifact, index: usize) -> Result<()> { + let name = format!("_table_{}", index); + // FIXME: We need to initialize table using function symbols + obj.define(name, Vec::new())?; + Ok(()) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +
+use crate::vmcontext::{ + VMContext, VMFunctionBody, VMGlobalDefinition, VMMemoryDefinition, VMTableDefinition, +}; +use wasmtime_environ::ir; +use wasmtime_environ::wasm::Global; +use wasmtime_environ::{MemoryPlan, TablePlan}; + +/// The value of an export passed from one instance to another. +#[derive(Debug, Clone)] +pub enum Export { + /// A function export value. + Function { + /// The address of the native-code function. + address: *const VMFunctionBody, + /// Pointer to the containing `VMContext`. + vmctx: *mut VMContext, + /// The function signature declaration, used for compatibilty checking. + signature: ir::Signature, + }, + + /// A table export value. + Table { + /// The address of the table descriptor. + definition: *mut VMTableDefinition, + /// Pointer to the containing `VMContext`. + vmctx: *mut VMContext, + /// The table declaration, used for compatibilty checking. + table: TablePlan, + }, + + /// A memory export value. + Memory { + /// The address of the memory descriptor. + definition: *mut VMMemoryDefinition, + /// Pointer to the containing `VMContext`. + vmctx: *mut VMContext, + /// The memory declaration, used for compatibilty checking. + memory: MemoryPlan, + }, + + /// A global export value. + Global { + /// The address of the global storage. + definition: *mut VMGlobalDefinition, + /// Pointer to the containing `VMContext`. + vmctx: *mut VMContext, + /// The global declaration, used for compatibilty checking. + global: Global, + }, +} + +impl Export { + /// Construct a function export value. + pub fn function( + address: *const VMFunctionBody, + vmctx: *mut VMContext, + signature: ir::Signature, + ) -> Self { + Self::Function { + address, + vmctx, + signature, + } + } + + /// Construct a table export value. + pub fn table( + definition: *mut VMTableDefinition, + vmctx: *mut VMContext, + table: TablePlan, + ) -> Self { + Self::Table { + definition, + vmctx, + table, + } + } + + /// Construct a memory export value. + pub fn memory( + definition: *mut VMMemoryDefinition, + vmctx: *mut VMContext, + memory: MemoryPlan, + ) -> Self { + Self::Memory { + definition, + vmctx, + memory, + } + } + + /// Construct a global export value. + pub fn global( + definition: *mut VMGlobalDefinition, + vmctx: *mut VMContext, + global: Global, + ) -> Self { + Self::Global { + definition, + vmctx, + global, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +
+use crate::instance::InstanceHandle; +use crate::vmcontext::{VMFunctionImport, VMGlobalImport, VMMemoryImport, VMTableImport}; +use std::collections::HashSet; +use wasmtime_environ::entity::{BoxedSlice, PrimaryMap}; +use wasmtime_environ::wasm::{FuncIndex, GlobalIndex, MemoryIndex, TableIndex}; + +/// Resolved import pointers. +#[derive(Clone)] +pub struct Imports { + /// The set of instances that the imports depend on. + pub dependencies: HashSet<InstanceHandle>, + + /// Resolved addresses for imported functions. + pub functions: BoxedSlice<FuncIndex, VMFunctionImport>, + + /// Resolved addresses for imported tables. + pub tables: BoxedSlice<TableIndex, VMTableImport>, + + /// Resolved addresses for imported memories. + pub memories: BoxedSlice<MemoryIndex, VMMemoryImport>, + + /// Resolved addresses for imported globals. + pub globals: BoxedSlice<GlobalIndex, VMGlobalImport>, +} + +impl Imports { + /// Construct a new `Imports` instance. + pub fn new( + dependencies: HashSet<InstanceHandle>, + function_imports: PrimaryMap<FuncIndex, VMFunctionImport>, + table_imports: PrimaryMap<TableIndex, VMTableImport>, + memory_imports: PrimaryMap<MemoryIndex, VMMemoryImport>, + global_imports: PrimaryMap<GlobalIndex, VMGlobalImport>, + ) -> Self { + Self { + dependencies, + functions: function_imports.into_boxed_slice(), + tables: table_imports.into_boxed_slice(), + memories: memory_imports.into_boxed_slice(), + globals: global_imports.into_boxed_slice(), + } + } + + /// Construct a new `Imports` instance with no imports. + pub fn none() -> Self { + Self { + dependencies: HashSet::new(), + functions: PrimaryMap::new().into_boxed_slice(), + tables: PrimaryMap::new().into_boxed_slice(), + memories: PrimaryMap::new().into_boxed_slice(), + globals: PrimaryMap::new().into_boxed_slice(), + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 + 100 + 101 + 102 + 103 + 104 + 105 + 106 + 107 + 108 + 109 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 120 + 121 + 122 + 123 + 124 + 125 + 126 + 127 + 128 + 129 + 130 + 131 + 132 + 133 + 134 + 135 + 136 + 137 + 138 + 139 + 140 + 141 + 142 + 143 + 144 + 145 + 146 + 147 + 148 + 149 + 150 + 151 + 152 + 153 + 154 + 155 + 156 + 157 + 158 + 159 + 160 + 161 + 162 + 163 + 164 + 165 + 166 + 167 + 168 + 169 + 170 + 171 + 172 + 173 + 174 + 175 + 176 + 177 + 178 + 179 + 180 + 181 + 182 + 183 + 184 + 185 + 186 + 187 + 188 + 189 + 190 + 191 + 192 + 193 + 194 + 195 + 196 + 197 + 198 + 199 + 200 + 201 + 202 + 203 + 204 + 205 + 206 + 207 + 208 + 209 + 210 + 211 + 212 + 213 + 214 + 215 + 216 + 217 + 218 + 219 + 220 + 221 + 222 + 223 + 224 + 225 + 226 + 227 + 228 + 229 + 230 + 231 + 232 + 233 + 234 + 235 + 236 + 237 + 238 + 239 + 240 + 241 + 242 + 243 + 244 + 245 + 246 + 247 + 248 + 249 + 250 + 251 + 252 + 253 + 254 + 255 + 256 + 257 + 258 + 259 + 260 + 261 + 262 + 263 + 264 + 265 + 266 + 267 + 268 + 269 + 270 + 271 + 272 + 273 + 274 + 275 + 276 + 277 + 278 + 279 + 280 + 281 + 282 + 283 + 284 + 285 + 286 + 287 + 288 + 289 + 290 + 291 + 292 + 293 + 294 + 295 + 296 + 297 + 298 + 299 + 300 + 301 + 302 + 303 + 304 + 305 + 306 + 307 + 308 + 309 + 310 + 311 + 312 + 313 + 314 + 315 + 316 + 317 + 318 + 319 + 320 + 321 + 322 + 323 + 324 + 325 + 326 + 327 + 328 + 329 + 330 + 331 + 332 + 333 + 334 + 335 + 336 + 337 + 338 + 339 + 340 + 341 + 342 + 343 + 344 + 345 + 346 + 347 + 348 + 349 + 350 + 351 + 352 + 353 + 354 + 355 + 356 + 357 + 358 + 359 + 360 + 361 + 362 + 363 + 364 + 365 + 366 + 367 + 368 + 369 + 370 + 371 + 372 + 373 + 374 + 375 + 376 + 377 + 378 + 379 + 380 + 381 + 382 + 383 + 384 + 385 + 386 + 387 + 388 + 389 + 390 + 391 + 392 + 393 + 394 + 395 + 396 + 397 + 398 + 399 + 400 + 401 + 402 + 403 + 404 + 405 + 406 + 407 + 408 + 409 + 410 + 411 + 412 + 413 + 414 + 415 + 416 + 417 + 418 + 419 + 420 + 421 + 422 + 423 + 424 + 425 + 426 + 427 + 428 + 429 + 430 + 431 + 432 + 433 + 434 + 435 + 436 + 437 + 438 + 439 + 440 + 441 + 442 + 443 + 444 + 445 + 446 + 447 + 448 + 449 + 450 + 451 + 452 + 453 + 454 + 455 + 456 + 457 + 458 + 459 + 460 + 461 + 462 + 463 + 464 + 465 + 466 + 467 + 468 + 469 + 470 + 471 + 472 + 473 + 474 + 475 + 476 + 477 + 478 + 479 + 480 + 481 + 482 + 483 + 484 + 485 + 486 + 487 + 488 + 489 + 490 + 491 + 492 + 493 + 494 + 495 + 496 + 497 + 498 + 499 + 500 + 501 + 502 + 503 + 504 + 505 + 506 + 507 + 508 + 509 + 510 + 511 + 512 + 513 + 514 + 515 + 516 + 517 + 518 + 519 + 520 + 521 + 522 + 523 + 524 + 525 + 526 + 527 + 528 + 529 + 530 + 531 + 532 + 533 + 534 + 535 + 536 + 537 + 538 + 539 + 540 + 541 + 542 + 543 + 544 + 545 + 546 + 547 + 548 + 549 + 550 + 551 + 552 + 553 + 554 + 555 + 556 + 557 + 558 + 559 + 560 + 561 + 562 + 563 + 564 + 565 + 566 + 567 + 568 + 569 + 570 + 571 + 572 + 573 + 574 + 575 + 576 + 577 + 578 + 579 + 580 + 581 + 582 + 583 + 584 + 585 + 586 + 587 + 588 + 589 + 590 + 591 + 592 + 593 + 594 + 595 + 596 + 597 + 598 + 599 + 600 + 601 + 602 + 603 + 604 + 605 + 606 + 607 + 608 + 609 + 610 + 611 + 612 + 613 + 614 + 615 + 616 + 617 + 618 + 619 + 620 + 621 + 622 + 623 + 624 + 625 + 626 + 627 + 628 + 629 + 630 + 631 + 632 + 633 + 634 + 635 + 636 + 637 + 638 + 639 + 640 + 641 + 642 + 643 + 644 + 645 + 646 + 647 + 648 + 649 + 650 + 651 + 652 + 653 + 654 + 655 + 656 + 657 + 658 + 659 + 660 + 661 + 662 + 663 + 664 + 665 + 666 + 667 + 668 + 669 + 670 + 671 + 672 + 673 + 674 + 675 + 676 + 677 + 678 + 679 + 680 + 681 + 682 + 683 + 684 + 685 + 686 + 687 + 688 + 689 + 690 + 691 + 692 + 693 + 694 + 695 + 696 + 697 + 698 + 699 + 700 + 701 + 702 + 703 + 704 + 705 + 706 + 707 + 708 + 709 + 710 + 711 + 712 + 713 + 714 + 715 + 716 + 717 + 718 + 719 + 720 + 721 + 722 + 723 + 724 + 725 + 726 + 727 + 728 + 729 + 730 + 731 + 732 + 733 + 734 + 735 + 736 + 737 + 738 + 739 + 740 + 741 + 742 + 743 + 744 + 745 + 746 + 747 + 748 + 749 + 750 + 751 + 752 + 753 + 754 + 755 + 756 + 757 + 758 + 759 + 760 + 761 + 762 + 763 + 764 + 765 + 766 + 767 + 768 + 769 + 770 + 771 + 772 + 773 + 774 + 775 + 776 + 777 + 778 + 779 + 780 + 781 + 782 + 783 + 784 + 785 + 786 + 787 + 788 + 789 + 790 + 791 + 792 + 793 + 794 + 795 + 796 + 797 + 798 + 799 + 800 + 801 + 802 + 803 + 804 + 805 + 806 + 807 + 808 + 809 + 810 + 811 + 812 + 813 + 814 + 815 + 816 + 817 + 818 + 819 + 820 + 821 + 822 + 823 + 824 + 825 + 826 + 827 + 828 + 829 + 830 + 831 + 832 + 833 + 834 + 835 + 836 + 837 + 838 + 839 + 840 + 841 + 842 + 843 + 844 + 845 + 846 + 847 + 848 + 849 + 850 + 851 + 852 + 853 + 854 + 855 + 856 + 857 + 858 + 859 + 860 + 861 + 862 + 863 + 864 + 865 + 866 + 867 + 868 + 869 + 870 + 871 + 872 + 873 + 874 + 875 + 876 + 877 + 878 + 879 + 880 + 881 + 882 + 883 + 884 + 885 + 886 + 887 + 888 + 889 + 890 + 891 + 892 + 893 + 894 + 895 + 896 + 897 + 898 + 899 + 900 + 901 + 902 + 903 + 904 + 905 + 906 + 907 + 908 + 909 + 910 + 911 + 912 + 913 + 914 + 915 + 916 + 917 + 918 + 919 + 920 + 921 + 922 + 923 + 924 + 925 + 926 + 927 + 928 + 929 + 930 + 931 + 932 + 933 + 934 + 935 + 936 + 937 + 938 + 939 + 940 + 941 + 942 + 943 + 944 + 945 + 946 + 947 + 948 + 949 + 950 + 951 + 952 + 953 + 954 + 955 + 956 + 957 + 958 + 959 + 960 + 961 + 962 + 963 + 964 + 965 + 966 + 967 + 968 + 969 + 970 + 971 + 972 + 973 + 974 + 975 + 976 + 977 + 978 + 979 + 980 + 981 + 982 + 983 + 984 + 985 + 986 + 987 + 988 + 989 + 990 + 991 + 992 + 993 + 994 + 995 + 996 + 997 + 998 + 999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +
+//! An `Instance` contains all the runtime state used by execution of a +//! wasm module (except its callstack and register state). An +//! `InstanceHandle` is a reference-counting handle for an `Instance`. + +use crate::export::Export; +use crate::imports::Imports; +use crate::jit_int::GdbJitImageRegistration; +use crate::memory::LinearMemory; +use crate::signalhandlers; +use crate::table::Table; +use crate::traphandlers::{catch_traps, Trap}; +use crate::vmcontext::{ + VMBuiltinFunctionsArray, VMCallerCheckedAnyfunc, VMContext, VMFunctionBody, VMFunctionImport, + VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition, VMMemoryImport, VMSharedSignatureIndex, + VMTableDefinition, VMTableImport, +}; +use crate::TrapRegistration; +use memoffset::offset_of; +use more_asserts::assert_lt; +use std::alloc::{self, Layout}; +use std::any::Any; +use std::cell::Cell; +use std::collections::HashSet; +use std::convert::TryFrom; +use std::rc::Rc; +use std::sync::Arc; +use std::{mem, ptr, slice}; +use thiserror::Error; +use wasmtime_environ::entity::{BoxedSlice, EntityRef, PrimaryMap}; +use wasmtime_environ::wasm::{ + DefinedFuncIndex, DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, FuncIndex, + GlobalIndex, GlobalInit, MemoryIndex, SignatureIndex, TableIndex, +}; +use wasmtime_environ::{DataInitializer, Module, TableElements, VMOffsets}; + +cfg_if::cfg_if! { + if #[cfg(unix)] { + pub type SignalHandler = dyn Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool; + + impl InstanceHandle { + /// Set a custom signal handler + pub fn set_signal_handler<H>(&mut self, handler: H) + where + H: 'static + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool, + { + self.instance().signal_handler.set(Some(Box::new(handler))); + } + } + } else if #[cfg(target_os = "windows")] { + pub type SignalHandler = dyn Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool; + + impl InstanceHandle { + /// Set a custom signal handler + pub fn set_signal_handler<H>(&mut self, handler: H) + where + H: 'static + Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool, + { + self.instance().signal_handler.set(Some(Box::new(handler))); + } + } + } +} + +/// A WebAssembly instance. +/// +/// This is repr(C) to ensure that the vmctx field is last. +#[repr(C)] +pub(crate) struct Instance { + /// The number of references to this `Instance`. + refcount: Cell<usize>, + + /// `Instance`s from which this `Instance` imports. These won't + /// create reference cycles because wasm instances can't cyclically + /// import from each other. + dependencies: HashSet<InstanceHandle>, + + /// The `Module` this `Instance` was instantiated from. + module: Arc<Module>, + + /// Offsets in the `vmctx` region. + offsets: VMOffsets, + + /// WebAssembly linear memory data. + memories: BoxedSlice<DefinedMemoryIndex, LinearMemory>, + + /// WebAssembly table data. + tables: BoxedSlice<DefinedTableIndex, Table>, + + /// Pointers to functions in executable memory. + finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>, + + /// Hosts can store arbitrary per-instance information here. + host_state: Box<dyn Any>, + + /// Optional image of JIT'ed code for debugger registration. + dbg_jit_registration: Option<Rc<GdbJitImageRegistration>>, + + /// Handler run when `SIGBUS`, `SIGFPE`, `SIGILL`, or `SIGSEGV` are caught by the instance thread. + pub(crate) signal_handler: Cell<Option<Box<SignalHandler>>>, + + /// Handle to our registration of traps so signals know what trap to return + /// when a segfault/sigill happens. + pub(crate) trap_registration: TrapRegistration, + + /// Additional context used by compiled wasm code. This field is last, and + /// represents a dynamically-sized array that extends beyond the nominal + /// end of the struct (similar to a flexible array member). + vmctx: VMContext, +} + +#[allow(clippy::cast_ptr_alignment)] +impl Instance { + /// Helper function to access various locations offset from our `*mut + /// VMContext` object. + unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *mut T { + (self.vmctx_ptr() as *mut u8) + .add(usize::try_from(offset).unwrap()) + .cast() + } + + /// Return the indexed `VMSharedSignatureIndex`. + fn signature_id(&self, index: SignatureIndex) -> VMSharedSignatureIndex { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { *self.signature_ids_ptr().add(index) } + } + + /// Return a pointer to the `VMSharedSignatureIndex`s. + fn signature_ids_ptr(&self) -> *mut VMSharedSignatureIndex { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_signature_ids_begin()) } + } + + /// Return the indexed `VMFunctionImport`. + fn imported_function(&self, index: FuncIndex) -> &VMFunctionImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_functions_ptr().add(index) } + } + + /// Return a pointer to the `VMFunctionImport`s. + fn imported_functions_ptr(&self) -> *mut VMFunctionImport { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_functions_begin()) } + } + + /// Return the index `VMTableImport`. + fn imported_table(&self, index: TableIndex) -> &VMTableImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_tables_ptr().add(index) } + } + + /// Return a pointer to the `VMTableImports`s. + fn imported_tables_ptr(&self) -> *mut VMTableImport { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_tables_begin()) } + } + + /// Return the indexed `VMMemoryImport`. + fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_memories_ptr().add(index) } + } + + /// Return a pointer to the `VMMemoryImport`s. + fn imported_memories_ptr(&self) -> *mut VMMemoryImport { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_memories_begin()) } + } + + /// Return the indexed `VMGlobalImport`. + fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_globals_ptr().add(index) } + } + + /// Return a pointer to the `VMGlobalImport`s. + fn imported_globals_ptr(&self) -> *mut VMGlobalImport { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_globals_begin()) } + } + + /// Return the indexed `VMTableDefinition`. + #[allow(dead_code)] + fn table(&self, index: DefinedTableIndex) -> VMTableDefinition { + unsafe { *self.table_ptr(index) } + } + + /// Updates the value for a defined table to `VMTableDefinition`. + fn set_table(&self, index: DefinedTableIndex, table: VMTableDefinition) { + unsafe { + *self.table_ptr(index) = table; + } + } + + /// Return the indexed `VMTableDefinition`. + fn table_ptr(&self, index: DefinedTableIndex) -> *mut VMTableDefinition { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { self.tables_ptr().add(index) } + } + + /// Return a pointer to the `VMTableDefinition`s. + fn tables_ptr(&self) -> *mut VMTableDefinition { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_tables_begin()) } + } + + /// Return the indexed `VMMemoryDefinition`. + fn memory(&self, index: DefinedMemoryIndex) -> VMMemoryDefinition { + unsafe { *self.memory_ptr(index) } + } + + /// Set the indexed memory to `VMMemoryDefinition`. + fn set_memory(&self, index: DefinedMemoryIndex, mem: VMMemoryDefinition) { + unsafe { + *self.memory_ptr(index) = mem; + } + } + + /// Return the indexed `VMMemoryDefinition`. + fn memory_ptr(&self, index: DefinedMemoryIndex) -> *mut VMMemoryDefinition { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { self.memories_ptr().add(index) } + } + + /// Return a pointer to the `VMMemoryDefinition`s. + fn memories_ptr(&self) -> *mut VMMemoryDefinition { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_memories_begin()) } + } + + /// Return the indexed `VMGlobalDefinition`. + fn global(&self, index: DefinedGlobalIndex) -> VMGlobalDefinition { + unsafe { *self.global_ptr(index) } + } + + /// Set the indexed global to `VMGlobalDefinition`. + #[allow(dead_code)] + fn set_global(&self, index: DefinedGlobalIndex, global: VMGlobalDefinition) { + unsafe { + *self.global_ptr(index) = global; + } + } + + /// Return the indexed `VMGlobalDefinition`. + fn global_ptr(&self, index: DefinedGlobalIndex) -> *mut VMGlobalDefinition { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { self.globals_ptr().add(index) } + } + + /// Return a pointer to the `VMGlobalDefinition`s. + fn globals_ptr(&self) -> *mut VMGlobalDefinition { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_globals_begin()) } + } + + /// Return a pointer to the `VMBuiltinFunctionsArray`. + fn builtin_functions_ptr(&self) -> *mut VMBuiltinFunctionsArray { + unsafe { self.vmctx_plus_offset(self.offsets.vmctx_builtin_functions_begin()) } + } + + /// Return a reference to the vmctx used by compiled wasm code. + pub fn vmctx(&self) -> &VMContext { + &self.vmctx + } + + /// Return a raw pointer to the vmctx used by compiled wasm code. + pub fn vmctx_ptr(&self) -> *mut VMContext { + self.vmctx() as *const VMContext as *mut VMContext + } + + /// Lookup an export with the given name. + pub fn lookup(&self, field: &str) -> Option<Export> { + let export = if let Some(export) = self.module.exports.get(field) { + export.clone() + } else { + return None; + }; + Some(self.lookup_by_declaration(&export)) + } + + /// Lookup an export with the given export declaration. + pub fn lookup_by_declaration(&self, export: &wasmtime_environ::Export) -> Export { + match export { + wasmtime_environ::Export::Function(index) => { + let signature = self.module.signatures[self.module.functions[*index]].clone(); + let (address, vmctx) = + if let Some(def_index) = self.module.defined_func_index(*index) { + ( + self.finished_functions[def_index] as *const _, + self.vmctx_ptr(), + ) + } else { + let import = self.imported_function(*index); + (import.body, import.vmctx) + }; + Export::Function { + address, + signature, + vmctx, + } + } + wasmtime_environ::Export::Table(index) => { + let (definition, vmctx) = + if let Some(def_index) = self.module.defined_table_index(*index) { + (self.table_ptr(def_index), self.vmctx_ptr()) + } else { + let import = self.imported_table(*index); + (import.from, import.vmctx) + }; + Export::Table { + definition, + vmctx, + table: self.module.table_plans[*index].clone(), + } + } + wasmtime_environ::Export::Memory(index) => { + let (definition, vmctx) = + if let Some(def_index) = self.module.defined_memory_index(*index) { + (self.memory_ptr(def_index), self.vmctx_ptr()) + } else { + let import = self.imported_memory(*index); + (import.from, import.vmctx) + }; + Export::Memory { + definition, + vmctx, + memory: self.module.memory_plans[*index].clone(), + } + } + wasmtime_environ::Export::Global(index) => Export::Global { + definition: if let Some(def_index) = self.module.defined_global_index(*index) { + self.global_ptr(def_index) + } else { + self.imported_global(*index).from + }, + vmctx: self.vmctx_ptr(), + global: self.module.globals[*index], + }, + } + } + + /// Return an iterator over the exports of this instance. + /// + /// Specifically, it provides access to the key-value pairs, where they keys + /// are export names, and the values are export declarations which can be + /// resolved `lookup_by_declaration`. + pub fn exports(&self) -> indexmap::map::Iter<String, wasmtime_environ::Export> { + self.module.exports.iter() + } + + /// Return a reference to the custom state attached to this instance. + pub fn host_state(&self) -> &dyn Any { + &*self.host_state + } + + /// Invoke the WebAssembly start function of the instance, if one is present. + fn invoke_start_function(&self) -> Result<(), InstantiationError> { + let start_index = match self.module.start_func { + Some(idx) => idx, + None => return Ok(()), + }; + + let (callee_address, callee_vmctx) = match self.module.defined_func_index(start_index) { + Some(defined_index) => { + let body = *self + .finished_functions + .get(defined_index) + .expect("function index is out of bounds"); + (body as *const _, self.vmctx_ptr()) + } + None => { + assert_lt!(start_index.index(), self.module.imported_funcs.len()); + let import = self.imported_function(start_index); + (import.body, import.vmctx) + } + }; + + // Make the call. + unsafe { + catch_traps(callee_vmctx, || { + mem::transmute::< + *const VMFunctionBody, + unsafe extern "C" fn(*mut VMContext, *mut VMContext), + >(callee_address)(callee_vmctx, self.vmctx_ptr()) + }) + .map_err(InstantiationError::StartTrap) + } + } + + /// Return the offset from the vmctx pointer to its containing Instance. + pub(crate) fn vmctx_offset() -> isize { + offset_of!(Self, vmctx) as isize + } + + /// Return the table index for the given `VMTableDefinition`. + pub(crate) fn table_index(&self, table: &VMTableDefinition) -> DefinedTableIndex { + let offsets = &self.offsets; + let begin = unsafe { + (&self.vmctx as *const VMContext as *const u8) + .add(usize::try_from(offsets.vmctx_tables_begin()).unwrap()) + } as *const VMTableDefinition; + let end: *const VMTableDefinition = table; + // TODO: Use `offset_from` once it stablizes. + let index = DefinedTableIndex::new( + (end as usize - begin as usize) / mem::size_of::<VMTableDefinition>(), + ); + assert_lt!(index.index(), self.tables.len()); + index + } + + /// Return the memory index for the given `VMMemoryDefinition`. + pub(crate) fn memory_index(&self, memory: &VMMemoryDefinition) -> DefinedMemoryIndex { + let offsets = &self.offsets; + let begin = unsafe { + (&self.vmctx as *const VMContext as *const u8) + .add(usize::try_from(offsets.vmctx_memories_begin()).unwrap()) + } as *const VMMemoryDefinition; + let end: *const VMMemoryDefinition = memory; + // TODO: Use `offset_from` once it stablizes. + let index = DefinedMemoryIndex::new( + (end as usize - begin as usize) / mem::size_of::<VMMemoryDefinition>(), + ); + assert_lt!(index.index(), self.memories.len()); + index + } + + /// Grow memory by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub(crate) fn memory_grow(&self, memory_index: DefinedMemoryIndex, delta: u32) -> Option<u32> { + let result = self + .memories + .get(memory_index) + .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index())) + .grow(delta); + + // Keep current the VMContext pointers used by compiled wasm code. + self.set_memory(memory_index, self.memories[memory_index].vmmemory()); + + result + } + + /// Grow imported memory by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + /// + /// # Safety + /// This and `imported_memory_size` are currently unsafe because they + /// dereference the memory import's pointers. + pub(crate) unsafe fn imported_memory_grow( + &self, + memory_index: MemoryIndex, + delta: u32, + ) -> Option<u32> { + let import = self.imported_memory(memory_index); + let foreign_instance = (&*import.vmctx).instance(); + let foreign_memory = &*import.from; + let foreign_index = foreign_instance.memory_index(foreign_memory); + + foreign_instance.memory_grow(foreign_index, delta) + } + + /// Returns the number of allocated wasm pages. + pub(crate) fn memory_size(&self, memory_index: DefinedMemoryIndex) -> u32 { + self.memories + .get(memory_index) + .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index())) + .size() + } + + /// Returns the number of allocated wasm pages in an imported memory. + /// + /// # Safety + /// This and `imported_memory_grow` are currently unsafe because they + /// dereference the memory import's pointers. + pub(crate) unsafe fn imported_memory_size(&self, memory_index: MemoryIndex) -> u32 { + let import = self.imported_memory(memory_index); + let foreign_instance = (&mut *import.vmctx).instance(); + let foreign_memory = &mut *import.from; + let foreign_index = foreign_instance.memory_index(foreign_memory); + + foreign_instance.memory_size(foreign_index) + } + + /// Grow table by the specified amount of elements. + /// + /// Returns `None` if table can't be grown by the specified amount + /// of elements. + pub(crate) fn table_grow(&self, table_index: DefinedTableIndex, delta: u32) -> Option<u32> { + let result = self + .tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .grow(delta); + + // Keep current the VMContext pointers used by compiled wasm code. + self.set_table(table_index, self.tables[table_index].vmtable()); + + result + } + + // Get table element by index. + fn table_get( + &self, + table_index: DefinedTableIndex, + index: u32, + ) -> Option<VMCallerCheckedAnyfunc> { + self.tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .get(index) + } + + fn table_set( + &self, + table_index: DefinedTableIndex, + index: u32, + val: VMCallerCheckedAnyfunc, + ) -> Result<(), ()> { + self.tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .set(index, val) + } + + fn alloc_layout(&self) -> Layout { + let size = mem::size_of_val(self) + .checked_add(usize::try_from(self.offsets.size_of_vmctx()).unwrap()) + .unwrap(); + let align = mem::align_of_val(self); + Layout::from_size_align(size, align).unwrap() + } +} + +/// A handle holding an `Instance` of a WebAssembly module. +#[derive(Hash, PartialEq, Eq)] +pub struct InstanceHandle { + instance: *mut Instance, +} + +impl InstanceHandle { + /// Create a new `InstanceHandle` pointing at a new `Instance`. + /// + /// # Unsafety + /// + /// This method is not necessarily inherently unsafe to call, but in general + /// the APIs of an `Instance` are quite unsafe and have not been really + /// audited for safety that much. As a result the unsafety here on this + /// method is a low-overhead way of saying "this is an extremely unsafe type + /// to work with". + /// + /// Extreme care must be taken when working with `InstanceHandle` and it's + /// recommended to have relatively intimate knowledge of how it works + /// internally if you'd like to do so. If possible it's recommended to use + /// the `wasmtime` crate API rather than this type since that is vetted for + /// safety. + pub unsafe fn new( + module: Arc<Module>, + trap_registration: TrapRegistration, + finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>, + imports: Imports, + data_initializers: &[DataInitializer<'_>], + vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>, + dbg_jit_registration: Option<Rc<GdbJitImageRegistration>>, + host_state: Box<dyn Any>, + ) -> Result<Self, InstantiationError> { + let tables = create_tables(&module); + let memories = create_memories(&module)?; + + let vmctx_tables = tables + .values() + .map(Table::vmtable) + .collect::<PrimaryMap<DefinedTableIndex, _>>() + .into_boxed_slice(); + + let vmctx_memories = memories + .values() + .map(LinearMemory::vmmemory) + .collect::<PrimaryMap<DefinedMemoryIndex, _>>() + .into_boxed_slice(); + + let vmctx_globals = create_globals(&module); + + let offsets = VMOffsets::new(mem::size_of::<*const u8>() as u8, &module); + + let handle = { + let instance = Instance { + refcount: Cell::new(1), + dependencies: imports.dependencies, + module, + offsets, + memories, + tables, + finished_functions, + dbg_jit_registration, + host_state, + signal_handler: Cell::new(None), + trap_registration, + vmctx: VMContext {}, + }; + let layout = instance.alloc_layout(); + let instance_ptr = alloc::alloc(layout) as *mut Instance; + if instance_ptr.is_null() { + alloc::handle_alloc_error(layout); + } + ptr::write(instance_ptr, instance); + InstanceHandle { + instance: instance_ptr, + } + }; + let instance = handle.instance(); + + ptr::copy( + vmshared_signatures.values().as_slice().as_ptr(), + instance.signature_ids_ptr() as *mut VMSharedSignatureIndex, + vmshared_signatures.len(), + ); + ptr::copy( + imports.functions.values().as_slice().as_ptr(), + instance.imported_functions_ptr() as *mut VMFunctionImport, + imports.functions.len(), + ); + ptr::copy( + imports.tables.values().as_slice().as_ptr(), + instance.imported_tables_ptr() as *mut VMTableImport, + imports.tables.len(), + ); + ptr::copy( + imports.memories.values().as_slice().as_ptr(), + instance.imported_memories_ptr() as *mut VMMemoryImport, + imports.memories.len(), + ); + ptr::copy( + imports.globals.values().as_slice().as_ptr(), + instance.imported_globals_ptr() as *mut VMGlobalImport, + imports.globals.len(), + ); + ptr::copy( + vmctx_tables.values().as_slice().as_ptr(), + instance.tables_ptr() as *mut VMTableDefinition, + vmctx_tables.len(), + ); + ptr::copy( + vmctx_memories.values().as_slice().as_ptr(), + instance.memories_ptr() as *mut VMMemoryDefinition, + vmctx_memories.len(), + ); + ptr::copy( + vmctx_globals.values().as_slice().as_ptr(), + instance.globals_ptr() as *mut VMGlobalDefinition, + vmctx_globals.len(), + ); + ptr::write( + instance.builtin_functions_ptr() as *mut VMBuiltinFunctionsArray, + VMBuiltinFunctionsArray::initialized(), + ); + + // Check initializer bounds before initializing anything. + check_table_init_bounds(instance)?; + check_memory_init_bounds(instance, data_initializers)?; + + // Apply the initializers. + initialize_tables(instance)?; + initialize_memories(instance, data_initializers)?; + initialize_globals(instance); + + // Ensure that our signal handlers are ready for action. + // TODO: Move these calls out of `InstanceHandle`. + signalhandlers::init(); + + // The WebAssembly spec specifies that the start function is + // invoked automatically at instantiation time. + instance.invoke_start_function()?; + + Ok(handle) + } + + /// Create a new `InstanceHandle` pointing at the instance + /// pointed to by the given `VMContext` pointer. + /// + /// # Safety + /// This is unsafe because it doesn't work on just any `VMContext`, it must + /// be a `VMContext` allocated as part of an `Instance`. + pub unsafe fn from_vmctx(vmctx: *mut VMContext) -> Self { + let instance = (&mut *vmctx).instance(); + instance.refcount.set(instance.refcount.get() + 1); + Self { + instance: instance as *const Instance as *mut Instance, + } + } + + /// Return a reference to the vmctx used by compiled wasm code. + pub fn vmctx(&self) -> &VMContext { + self.instance().vmctx() + } + + /// Return a raw pointer to the vmctx used by compiled wasm code. + pub fn vmctx_ptr(&self) -> *mut VMContext { + self.instance().vmctx_ptr() + } + + /// Return a reference-counting pointer to a module. + pub fn module(&self) -> &Arc<Module> { + &self.instance().module + } + + /// Return a reference to a module. + pub fn module_ref(&self) -> &Module { + &self.instance().module + } + + /// Lookup an export with the given name. + pub fn lookup(&self, field: &str) -> Option<Export> { + self.instance().lookup(field) + } + + /// Lookup an export with the given export declaration. + pub fn lookup_by_declaration(&self, export: &wasmtime_environ::Export) -> Export { + self.instance().lookup_by_declaration(export) + } + + /// Return an iterator over the exports of this instance. + /// + /// Specifically, it provides access to the key-value pairs, where the keys + /// are export names, and the values are export declarations which can be + /// resolved `lookup_by_declaration`. + pub fn exports(&self) -> indexmap::map::Iter<String, wasmtime_environ::Export> { + self.instance().exports() + } + + /// Return a reference to the custom state attached to this instance. + pub fn host_state(&self) -> &dyn Any { + self.instance().host_state() + } + + /// Return the memory index for the given `VMMemoryDefinition` in this instance. + pub fn memory_index(&self, memory: &VMMemoryDefinition) -> DefinedMemoryIndex { + self.instance().memory_index(memory) + } + + /// Grow memory in this instance by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub fn memory_grow(&self, memory_index: DefinedMemoryIndex, delta: u32) -> Option<u32> { + self.instance().memory_grow(memory_index, delta) + } + + /// Return the table index for the given `VMTableDefinition` in this instance. + pub fn table_index(&self, table: &VMTableDefinition) -> DefinedTableIndex { + self.instance().table_index(table) + } + + /// Grow table in this instance by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub fn table_grow(&self, table_index: DefinedTableIndex, delta: u32) -> Option<u32> { + self.instance().table_grow(table_index, delta) + } + + /// Get table element reference. + /// + /// Returns `None` if index is out of bounds. + pub fn table_get( + &self, + table_index: DefinedTableIndex, + index: u32, + ) -> Option<VMCallerCheckedAnyfunc> { + self.instance().table_get(table_index, index) + } + + /// Set table element reference. + /// + /// Returns an error if the index is out of bounds + pub fn table_set( + &self, + table_index: DefinedTableIndex, + index: u32, + val: VMCallerCheckedAnyfunc, + ) -> Result<(), ()> { + self.instance().table_set(table_index, index, val) + } + + /// Return a reference to the contained `Instance`. + pub(crate) fn instance(&self) -> &Instance { + unsafe { &*(self.instance as *const Instance) } + } +} + +impl Clone for InstanceHandle { + fn clone(&self) -> Self { + let instance = self.instance(); + instance.refcount.set(instance.refcount.get() + 1); + Self { + instance: self.instance, + } + } +} + +impl Drop for InstanceHandle { + fn drop(&mut self) { + let instance = self.instance(); + let count = instance.refcount.get(); + instance.refcount.set(count - 1); + if count == 1 { + let layout = instance.alloc_layout(); + unsafe { + ptr::drop_in_place(self.instance); + alloc::dealloc(self.instance.cast(), layout); + } + } + } +} + +fn check_table_init_bounds(instance: &Instance) -> Result<(), InstantiationError> { + let module = Arc::clone(&instance.module); + for init in &module.table_elements { + let start = get_table_init_start(init, instance); + let table = get_table(init, instance); + + let size = usize::try_from(table.size()).unwrap(); + if size < start + init.elements.len() { + return Err(InstantiationError::Link(LinkError( + "elements segment does not fit".to_owned(), + ))); + } + } + + Ok(()) +} + +/// Compute the offset for a memory data initializer. +fn get_memory_init_start(init: &DataInitializer<'_>, instance: &Instance) -> usize { + let mut start = init.location.offset; + + if let Some(base) = init.location.base { + let val = unsafe { + if let Some(def_index) = instance.module.defined_global_index(base) { + *instance.global(def_index).as_u32() + } else { + *(*instance.imported_global(base).from).as_u32() + } + }; + start += usize::try_from(val).unwrap(); + } + + start +} + +/// Return a byte-slice view of a memory's data. +unsafe fn get_memory_slice<'instance>( + init: &DataInitializer<'_>, + instance: &'instance Instance, +) -> &'instance mut [u8] { + let memory = if let Some(defined_memory_index) = instance + .module + .defined_memory_index(init.location.memory_index) + { + instance.memory(defined_memory_index) + } else { + let import = instance.imported_memory(init.location.memory_index); + let foreign_instance = (&mut *(import).vmctx).instance(); + let foreign_memory = &mut *(import).from; + let foreign_index = foreign_instance.memory_index(foreign_memory); + foreign_instance.memory(foreign_index) + }; + slice::from_raw_parts_mut(memory.base, memory.current_length) +} + +fn check_memory_init_bounds( + instance: &Instance, + data_initializers: &[DataInitializer<'_>], +) -> Result<(), InstantiationError> { + for init in data_initializers { + let start = get_memory_init_start(init, instance); + unsafe { + let mem_slice = get_memory_slice(init, instance); + if mem_slice.get_mut(start..start + init.data.len()).is_none() { + return Err(InstantiationError::Link(LinkError( + "data segment does not fit".to_owned(), + ))); + } + } + } + + Ok(()) +} + +/// Allocate memory for just the tables of the current module. +fn create_tables(module: &Module) -> BoxedSlice<DefinedTableIndex, Table> { + let num_imports = module.imported_tables.len(); + let mut tables: PrimaryMap<DefinedTableIndex, _> = + PrimaryMap::with_capacity(module.table_plans.len() - num_imports); + for table in &module.table_plans.values().as_slice()[num_imports..] { + tables.push(Table::new(table)); + } + tables.into_boxed_slice() +} + +/// Compute the offset for a table element initializer. +fn get_table_init_start(init: &TableElements, instance: &Instance) -> usize { + let mut start = init.offset; + + if let Some(base) = init.base { + let val = unsafe { + if let Some(def_index) = instance.module.defined_global_index(base) { + *instance.global(def_index).as_u32() + } else { + *(*instance.imported_global(base).from).as_u32() + } + }; + start += usize::try_from(val).unwrap(); + } + + start +} + +/// Return a byte-slice view of a table's data. +fn get_table<'instance>(init: &TableElements, instance: &'instance Instance) -> &'instance Table { + if let Some(defined_table_index) = instance.module.defined_table_index(init.table_index) { + &instance.tables[defined_table_index] + } else { + let import = instance.imported_table(init.table_index); + let foreign_instance = unsafe { (&mut *(import).vmctx).instance() }; + let foreign_table = unsafe { &mut *(import).from }; + let foreign_index = foreign_instance.table_index(foreign_table); + &foreign_instance.tables[foreign_index] + } +} + +/// Initialize the table memory from the provided initializers. +fn initialize_tables(instance: &Instance) -> Result<(), InstantiationError> { + let vmctx = instance.vmctx_ptr(); + let module = Arc::clone(&instance.module); + for init in &module.table_elements { + let start = get_table_init_start(init, instance); + let table = get_table(init, instance); + + for (i, func_idx) in init.elements.iter().enumerate() { + let callee_sig = instance.module.functions[*func_idx]; + let (callee_ptr, callee_vmctx) = + if let Some(index) = instance.module.defined_func_index(*func_idx) { + (instance.finished_functions[index] as *const _, vmctx) + } else { + let imported_func = instance.imported_function(*func_idx); + (imported_func.body, imported_func.vmctx) + }; + let type_index = instance.signature_id(callee_sig); + table + .set( + u32::try_from(start + i).unwrap(), + VMCallerCheckedAnyfunc { + func_ptr: callee_ptr, + type_index, + vmctx: callee_vmctx, + }, + ) + .unwrap(); + } + } + + Ok(()) +} + +/// Allocate memory for just the memories of the current module. +fn create_memories( + module: &Module, +) -> Result<BoxedSlice<DefinedMemoryIndex, LinearMemory>, InstantiationError> { + let num_imports = module.imported_memories.len(); + let mut memories: PrimaryMap<DefinedMemoryIndex, _> = + PrimaryMap::with_capacity(module.memory_plans.len() - num_imports); + for plan in &module.memory_plans.values().as_slice()[num_imports..] { + memories.push(LinearMemory::new(plan).map_err(InstantiationError::Resource)?); + } + Ok(memories.into_boxed_slice()) +} + +/// Initialize the table memory from the provided initializers. +fn initialize_memories( + instance: &Instance, + data_initializers: &[DataInitializer<'_>], +) -> Result<(), InstantiationError> { + for init in data_initializers { + let start = get_memory_init_start(init, instance); + unsafe { + let mem_slice = get_memory_slice(init, instance); + let to_init = &mut mem_slice[start..start + init.data.len()]; + to_init.copy_from_slice(init.data); + } + } + + Ok(()) +} + +/// Allocate memory for just the globals of the current module, +/// with initializers applied. +fn create_globals(module: &Module) -> BoxedSlice<DefinedGlobalIndex, VMGlobalDefinition> { + let num_imports = module.imported_globals.len(); + let mut vmctx_globals = PrimaryMap::with_capacity(module.globals.len() - num_imports); + + for _ in &module.globals.values().as_slice()[num_imports..] { + vmctx_globals.push(VMGlobalDefinition::new()); + } + + vmctx_globals.into_boxed_slice() +} + +fn initialize_globals(instance: &Instance) { + let module = Arc::clone(&instance.module); + let num_imports = module.imported_globals.len(); + for (index, global) in module.globals.iter().skip(num_imports) { + let def_index = module.defined_global_index(index).unwrap(); + unsafe { + let to = instance.global_ptr(def_index); + match global.initializer { + GlobalInit::I32Const(x) => *(*to).as_i32_mut() = x, + GlobalInit::I64Const(x) => *(*to).as_i64_mut() = x, + GlobalInit::F32Const(x) => *(*to).as_f32_bits_mut() = x, + GlobalInit::F64Const(x) => *(*to).as_f64_bits_mut() = x, + GlobalInit::V128Const(x) => *(*to).as_u128_bits_mut() = x.0, + GlobalInit::GetGlobal(x) => { + let from = if let Some(def_x) = module.defined_global_index(x) { + instance.global(def_x) + } else { + *instance.imported_global(x).from + }; + *to = from; + } + GlobalInit::Import => panic!("locally-defined global initialized as import"), + GlobalInit::RefNullConst | GlobalInit::RefFunc(_) => unimplemented!(), + } + } + } +} + +/// An link error while instantiating a module. +#[derive(Error, Debug)] +#[error("Link error: {0}")] +pub struct LinkError(pub String); + +/// An error while instantiating a module. +#[derive(Error, Debug)] +pub enum InstantiationError { + /// Insufficient resources available for execution. + #[error("Insufficient resources: {0}")] + Resource(String), + + /// A wasm link error occured. + #[error("Failed to link module")] + Link(#[from] LinkError), + + /// A compilation error occured. + #[error("Trap occurred while invoking start function")] + StartTrap(#[source] Trap), +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +
+//! The GDB's JIT compilation interface. The low level module that exposes +//! the __jit_debug_register_code() and __jit_debug_descriptor to register +//! or unregister generated object images with debuggers. + +use std::ptr; + +#[repr(C)] +struct JITCodeEntry { + next_entry: *mut JITCodeEntry, + prev_entry: *mut JITCodeEntry, + symfile_addr: *const u8, + symfile_size: u64, +} + +const JIT_NOACTION: u32 = 0; +const JIT_REGISTER_FN: u32 = 1; +const JIT_UNREGISTER_FN: u32 = 2; + +#[repr(C)] +struct JITDescriptor { + version: u32, + action_flag: u32, + relevant_entry: *mut JITCodeEntry, + first_entry: *mut JITCodeEntry, +} + +#[no_mangle] +#[used] +static mut __jit_debug_descriptor: JITDescriptor = JITDescriptor { + version: 1, + action_flag: JIT_NOACTION, + relevant_entry: ptr::null_mut(), + first_entry: ptr::null_mut(), +}; + +#[no_mangle] +#[inline(never)] +extern "C" fn __jit_debug_register_code() { + // Hack to not allow inlining even when Rust wants to do it in release mode. + let x = 3; + unsafe { + std::ptr::read_volatile(&x); + } +} + +/// Registeration for JIT image +pub struct GdbJitImageRegistration { + entry: *mut JITCodeEntry, + file: Vec<u8>, +} + +impl GdbJitImageRegistration { + /// Registers JIT image using __jit_debug_register_code + pub fn register(file: Vec<u8>) -> Self { + Self { + entry: unsafe { register_gdb_jit_image(&file) }, + file, + } + } + + /// JIT image used in registration + pub fn file(&self) -> &[u8] { + &self.file + } +} + +impl Drop for GdbJitImageRegistration { + fn drop(&mut self) { + unsafe { + unregister_gdb_jit_image(self.entry); + } + } +} + +unsafe fn register_gdb_jit_image(file: &[u8]) -> *mut JITCodeEntry { + // Create a code entry for the file, which gives the start and size of the symbol file. + let entry = Box::into_raw(Box::new(JITCodeEntry { + next_entry: __jit_debug_descriptor.first_entry, + prev_entry: ptr::null_mut(), + symfile_addr: file.as_ptr(), + symfile_size: file.len() as u64, + })); + // Add it to the linked list in the JIT descriptor. + if !__jit_debug_descriptor.first_entry.is_null() { + (*__jit_debug_descriptor.first_entry).prev_entry = entry; + } + __jit_debug_descriptor.first_entry = entry; + // Point the relevant_entry field of the descriptor at the entry. + __jit_debug_descriptor.relevant_entry = entry; + // Set action_flag to JIT_REGISTER and call __jit_debug_register_code. + __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; + __jit_debug_register_code(); + + __jit_debug_descriptor.action_flag = JIT_NOACTION; + __jit_debug_descriptor.relevant_entry = ptr::null_mut(); + entry +} + +unsafe fn unregister_gdb_jit_image(entry: *mut JITCodeEntry) { + // Remove the code entry corresponding to the code from the linked list. + if !(*entry).prev_entry.is_null() { + (*(*entry).prev_entry).next_entry = (*entry).next_entry; + } else { + __jit_debug_descriptor.first_entry = (*entry).next_entry; + } + if !(*entry).next_entry.is_null() { + (*(*entry).next_entry).prev_entry = (*entry).prev_entry; + } + // Point the relevant_entry field of the descriptor at the code entry. + __jit_debug_descriptor.relevant_entry = entry; + // Set action_flag to JIT_UNREGISTER and call __jit_debug_register_code. + __jit_debug_descriptor.action_flag = JIT_UNREGISTER_FN; + __jit_debug_register_code(); + + __jit_debug_descriptor.action_flag = JIT_NOACTION; + __jit_debug_descriptor.relevant_entry = ptr::null_mut(); + let _box = Box::from_raw(entry); +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +
+//! Runtime library support for Wasmtime. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod export; +mod imports; +mod instance; +mod jit_int; +mod memory; +mod mmap; +mod sig_registry; +mod signalhandlers; +mod table; +mod trap_registry; +mod traphandlers; +mod vmcontext; + +pub mod libcalls; + +pub use crate::export::Export; +pub use crate::imports::Imports; +pub use crate::instance::{InstanceHandle, InstantiationError, LinkError}; +pub use crate::jit_int::GdbJitImageRegistration; +pub use crate::mmap::Mmap; +pub use crate::sig_registry::SignatureRegistry; +pub use crate::trap_registry::{TrapDescription, TrapRegistration, TrapRegistry}; +pub use crate::traphandlers::resume_panic; +pub use crate::traphandlers::{catch_traps, raise_user_trap, wasmtime_call_trampoline, Trap}; +pub use crate::vmcontext::{ + VMCallerCheckedAnyfunc, VMContext, VMFunctionBody, VMFunctionImport, VMGlobalDefinition, + VMGlobalImport, VMInvokeArgument, VMMemoryDefinition, VMMemoryImport, VMSharedSignatureIndex, + VMTableDefinition, VMTableImport, +}; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +
+//! Runtime library calls. Note that wasm compilers may sometimes perform these +//! inline rather than calling them, particularly when CPUs have special +//! instructions which compute them directly. + +use crate::vmcontext::VMContext; +use wasmtime_environ::wasm::{DefinedMemoryIndex, MemoryIndex}; + +/// Implementation of f32.ceil +pub extern "C" fn wasmtime_f32_ceil(x: f32) -> f32 { + x.ceil() +} + +/// Implementation of f32.floor +pub extern "C" fn wasmtime_f32_floor(x: f32) -> f32 { + x.floor() +} + +/// Implementation of f32.trunc +pub extern "C" fn wasmtime_f32_trunc(x: f32) -> f32 { + x.trunc() +} + +/// Implementation of f32.nearest +#[allow(clippy::float_arithmetic, clippy::float_cmp)] +pub extern "C" fn wasmtime_f32_nearest(x: f32) -> f32 { + // Rust doesn't have a nearest function, so do it manually. + if x == 0.0 { + // Preserve the sign of zero. + x + } else { + // Nearest is either ceil or floor depending on which is nearest or even. + let u = x.ceil(); + let d = x.floor(); + let um = (x - u).abs(); + let dm = (x - d).abs(); + if um < dm + || (um == dm && { + let h = u / 2.; + h.floor() == h + }) + { + u + } else { + d + } + } +} + +/// Implementation of f64.ceil +pub extern "C" fn wasmtime_f64_ceil(x: f64) -> f64 { + x.ceil() +} + +/// Implementation of f64.floor +pub extern "C" fn wasmtime_f64_floor(x: f64) -> f64 { + x.floor() +} + +/// Implementation of f64.trunc +pub extern "C" fn wasmtime_f64_trunc(x: f64) -> f64 { + x.trunc() +} + +/// Implementation of f64.nearest +#[allow(clippy::float_arithmetic, clippy::float_cmp)] +pub extern "C" fn wasmtime_f64_nearest(x: f64) -> f64 { + // Rust doesn't have a nearest function, so do it manually. + if x == 0.0 { + // Preserve the sign of zero. + x + } else { + // Nearest is either ceil or floor depending on which is nearest or even. + let u = x.ceil(); + let d = x.floor(); + let um = (x - u).abs(); + let dm = (x - d).abs(); + if um < dm + || (um == dm && { + let h = u / 2.; + h.floor() == h + }) + { + u + } else { + d + } + } +} + +/// Implementation of memory.grow for locally-defined 32-bit memories. +#[no_mangle] +pub unsafe extern "C" fn wasmtime_memory32_grow( + vmctx: *mut VMContext, + delta: u32, + memory_index: u32, +) -> u32 { + let instance = (&mut *vmctx).instance(); + let memory_index = DefinedMemoryIndex::from_u32(memory_index); + + instance + .memory_grow(memory_index, delta) + .unwrap_or(u32::max_value()) +} + +/// Implementation of memory.grow for imported 32-bit memories. +#[no_mangle] +pub unsafe extern "C" fn wasmtime_imported_memory32_grow( + vmctx: *mut VMContext, + delta: u32, + memory_index: u32, +) -> u32 { + let instance = (&mut *vmctx).instance(); + let memory_index = MemoryIndex::from_u32(memory_index); + + instance + .imported_memory_grow(memory_index, delta) + .unwrap_or(u32::max_value()) +} + +/// Implementation of memory.size for locally-defined 32-bit memories. +#[no_mangle] +pub unsafe extern "C" fn wasmtime_memory32_size(vmctx: *mut VMContext, memory_index: u32) -> u32 { + let instance = (&mut *vmctx).instance(); + let memory_index = DefinedMemoryIndex::from_u32(memory_index); + + instance.memory_size(memory_index) +} + +/// Implementation of memory.size for imported 32-bit memories. +#[no_mangle] +pub unsafe extern "C" fn wasmtime_imported_memory32_size( + vmctx: *mut VMContext, + memory_index: u32, +) -> u32 { + let instance = (&mut *vmctx).instance(); + let memory_index = MemoryIndex::from_u32(memory_index); + + instance.imported_memory_size(memory_index) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +
+//! Memory management for linear memories. +//! +//! `LinearMemory` is to WebAssembly linear memories what `Table` is to WebAssembly tables. + +use crate::mmap::Mmap; +use crate::vmcontext::VMMemoryDefinition; +use more_asserts::{assert_ge, assert_le}; +use std::cell::RefCell; +use std::convert::TryFrom; +use wasmtime_environ::{MemoryPlan, MemoryStyle, WASM_MAX_PAGES, WASM_PAGE_SIZE}; + +/// A linear memory instance. +#[derive(Debug)] +pub struct LinearMemory { + // The underlying allocation. + mmap: RefCell<WasmMmap>, + + // The optional maximum size in wasm pages of this linear memory. + maximum: Option<u32>, + + // Size in bytes of extra guard pages after the end to optimize loads and stores with + // constant offsets. + offset_guard_size: usize, + + // Records whether we're using a bounds-checking strategy which requires + // handlers to catch trapping accesses. + pub(crate) needs_signal_handlers: bool, +} + +#[derive(Debug)] +struct WasmMmap { + // Our OS allocation of mmap'd memory. + alloc: Mmap, + // The current logical size in wasm pages of this linear memory. + size: u32, +} + +impl LinearMemory { + /// Create a new linear memory instance with specified minimum and maximum number of wasm pages. + pub fn new(plan: &MemoryPlan) -> Result<Self, String> { + // `maximum` cannot be set to more than `65536` pages. + assert_le!(plan.memory.minimum, WASM_MAX_PAGES); + assert!(plan.memory.maximum.is_none() || plan.memory.maximum.unwrap() <= WASM_MAX_PAGES); + + let offset_guard_bytes = plan.offset_guard_size as usize; + + // If we have an offset guard, or if we're doing the static memory + // allocation strategy, we need signal handlers to catch out of bounds + // acceses. + let needs_signal_handlers = offset_guard_bytes > 0 + || match plan.style { + MemoryStyle::Dynamic => false, + MemoryStyle::Static { .. } => true, + }; + + let minimum_pages = match plan.style { + MemoryStyle::Dynamic => plan.memory.minimum, + MemoryStyle::Static { bound } => { + assert_ge!(bound, plan.memory.minimum); + bound + } + } as usize; + let minimum_bytes = minimum_pages.checked_mul(WASM_PAGE_SIZE as usize).unwrap(); + let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap(); + let mapped_pages = plan.memory.minimum as usize; + let mapped_bytes = mapped_pages * WASM_PAGE_SIZE as usize; + + let mmap = WasmMmap { + alloc: Mmap::accessible_reserved(mapped_bytes, request_bytes)?, + size: plan.memory.minimum, + }; + + Ok(Self { + mmap: mmap.into(), + maximum: plan.memory.maximum, + offset_guard_size: offset_guard_bytes, + needs_signal_handlers, + }) + } + + /// Returns the number of allocated wasm pages. + pub fn size(&self) -> u32 { + self.mmap.borrow().size + } + + /// Grow memory by the specified amount of wasm pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of wasm pages. + pub fn grow(&self, delta: u32) -> Option<u32> { + // Optimization of memory.grow 0 calls. + let mut mmap = self.mmap.borrow_mut(); + if delta == 0 { + return Some(mmap.size); + } + + let new_pages = match mmap.size.checked_add(delta) { + Some(new_pages) => new_pages, + // Linear memory size overflow. + None => return None, + }; + let prev_pages = mmap.size; + + if let Some(maximum) = self.maximum { + if new_pages > maximum { + // Linear memory size would exceed the declared maximum. + return None; + } + } + + // Wasm linear memories are never allowed to grow beyond what is + // indexable. If the memory has no maximum, enforce the greatest + // limit here. + if new_pages >= WASM_MAX_PAGES { + // Linear memory size would exceed the index range. + return None; + } + + let delta_bytes = usize::try_from(delta).unwrap() * WASM_PAGE_SIZE as usize; + let prev_bytes = usize::try_from(prev_pages).unwrap() * WASM_PAGE_SIZE as usize; + let new_bytes = usize::try_from(new_pages).unwrap() * WASM_PAGE_SIZE as usize; + + if new_bytes > mmap.alloc.len() - self.offset_guard_size { + // If the new size is within the declared maximum, but needs more memory than we + // have on hand, it's a dynamic heap and it can move. + let guard_bytes = self.offset_guard_size; + let request_bytes = new_bytes.checked_add(guard_bytes)?; + + let mut new_mmap = Mmap::accessible_reserved(new_bytes, request_bytes).ok()?; + + let copy_len = mmap.alloc.len() - self.offset_guard_size; + new_mmap.as_mut_slice()[..copy_len].copy_from_slice(&mmap.alloc.as_slice()[..copy_len]); + + mmap.alloc = new_mmap; + } else if delta_bytes > 0 { + // Make the newly allocated pages accessible. + mmap.alloc.make_accessible(prev_bytes, delta_bytes).ok()?; + } + + mmap.size = new_pages; + + Some(prev_pages) + } + + /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code. + pub fn vmmemory(&self) -> VMMemoryDefinition { + let mut mmap = self.mmap.borrow_mut(); + VMMemoryDefinition { + base: mmap.alloc.as_mut_ptr(), + current_length: mmap.size as usize * WASM_PAGE_SIZE as usize, + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +
+//! Low-level abstraction for allocating and managing zero-filled pages +//! of memory. + +use more_asserts::assert_le; +use more_asserts::assert_lt; +use std::io; +use std::ptr; +use std::slice; + +/// Round `size` up to the nearest multiple of `page_size`. +fn round_up_to_page_size(size: usize, page_size: usize) -> usize { + (size + (page_size - 1)) & !(page_size - 1) +} + +/// A simple struct consisting of a page-aligned pointer to page-aligned +/// and initially-zeroed memory and a length. +#[derive(Debug)] +pub struct Mmap { + // Note that this is stored as a `usize` instead of a `*const` or `*mut` + // pointer to allow this structure to be natively `Send` and `Sync` without + // `unsafe impl`. This type is sendable across threads and shareable since + // the coordination all happens at the OS layer. + ptr: usize, + len: usize, +} + +impl Mmap { + /// Construct a new empty instance of `Mmap`. + pub fn new() -> Self { + // Rust's slices require non-null pointers, even when empty. `Vec` + // contains code to create a non-null dangling pointer value when + // constructed empty, so we reuse that here. + let empty = Vec::<u8>::new(); + Self { + ptr: empty.as_ptr() as usize, + len: 0, + } + } + + /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory. + pub fn with_at_least(size: usize) -> Result<Self, String> { + let page_size = region::page::size(); + let rounded_size = round_up_to_page_size(size, page_size); + Self::accessible_reserved(rounded_size, rounded_size) + } + + /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory, + /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size` + /// must be native page-size multiples. + #[cfg(not(target_os = "windows"))] + pub fn accessible_reserved( + accessible_size: usize, + mapping_size: usize, + ) -> Result<Self, String> { + let page_size = region::page::size(); + assert_le!(accessible_size, mapping_size); + assert_eq!(mapping_size & (page_size - 1), 0); + assert_eq!(accessible_size & (page_size - 1), 0); + + // Mmap may return EINVAL if the size is zero, so just + // special-case that. + if mapping_size == 0 { + return Ok(Self::new()); + } + + Ok(if accessible_size == mapping_size { + // Allocate a single read-write region at once. + let ptr = unsafe { + libc::mmap( + ptr::null_mut(), + mapping_size, + libc::PROT_READ | libc::PROT_WRITE, + libc::MAP_PRIVATE | libc::MAP_ANON, + -1, + 0, + ) + }; + if ptr as isize == -1_isize { + return Err(io::Error::last_os_error().to_string()); + } + + Self { + ptr: ptr as usize, + len: mapping_size, + } + } else { + // Reserve the mapping size. + let ptr = unsafe { + libc::mmap( + ptr::null_mut(), + mapping_size, + libc::PROT_NONE, + libc::MAP_PRIVATE | libc::MAP_ANON, + -1, + 0, + ) + }; + if ptr as isize == -1_isize { + return Err(io::Error::last_os_error().to_string()); + } + + let mut result = Self { + ptr: ptr as usize, + len: mapping_size, + }; + + if accessible_size != 0 { + // Commit the accessible size. + result.make_accessible(0, accessible_size)?; + } + + result + }) + } + + /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory, + /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size` + /// must be native page-size multiples. + #[cfg(target_os = "windows")] + pub fn accessible_reserved( + accessible_size: usize, + mapping_size: usize, + ) -> Result<Self, String> { + use winapi::um::memoryapi::VirtualAlloc; + use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE}; + + let page_size = region::page::size(); + assert_le!(accessible_size, mapping_size); + assert_eq!(mapping_size & (page_size - 1), 0); + assert_eq!(accessible_size & (page_size - 1), 0); + + Ok(if accessible_size == mapping_size { + // Allocate a single read-write region at once. + let ptr = unsafe { + VirtualAlloc( + ptr::null_mut(), + mapping_size, + MEM_RESERVE | MEM_COMMIT, + PAGE_READWRITE, + ) + }; + if ptr.is_null() { + return Err(io::Error::last_os_error().to_string()); + } + + Self { + ptr: ptr as usize, + len: mapping_size, + } + } else { + // Reserve the mapping size. + let ptr = + unsafe { VirtualAlloc(ptr::null_mut(), mapping_size, MEM_RESERVE, PAGE_NOACCESS) }; + if ptr.is_null() { + return Err(io::Error::last_os_error().to_string()); + } + + let mut result = Self { + ptr: ptr as usize, + len: mapping_size, + }; + + if accessible_size != 0 { + // Commit the accessible size. + result.make_accessible(0, accessible_size)?; + } + + result + }) + } + + /// Make the memory starting at `start` and extending for `len` bytes accessible. + /// `start` and `len` must be native page-size multiples and describe a range within + /// `self`'s reserved memory. + #[cfg(not(target_os = "windows"))] + pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> { + let page_size = region::page::size(); + assert_eq!(start & (page_size - 1), 0); + assert_eq!(len & (page_size - 1), 0); + assert_lt!(len, self.len); + assert_lt!(start, self.len - len); + + // Commit the accessible size. + let ptr = self.ptr as *const u8; + unsafe { region::protect(ptr.add(start), len, region::Protection::ReadWrite) } + .map_err(|e| e.to_string()) + } + + /// Make the memory starting at `start` and extending for `len` bytes accessible. + /// `start` and `len` must be native page-size multiples and describe a range within + /// `self`'s reserved memory. + #[cfg(target_os = "windows")] + pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> { + use winapi::ctypes::c_void; + use winapi::um::memoryapi::VirtualAlloc; + use winapi::um::winnt::{MEM_COMMIT, PAGE_READWRITE}; + let page_size = region::page::size(); + assert_eq!(start & (page_size - 1), 0); + assert_eq!(len & (page_size - 1), 0); + assert_lt!(len, self.len); + assert_lt!(start, self.len - len); + + // Commit the accessible size. + let ptr = self.ptr as *const u8; + if unsafe { + VirtualAlloc( + ptr.add(start) as *mut c_void, + len, + MEM_COMMIT, + PAGE_READWRITE, + ) + } + .is_null() + { + return Err(io::Error::last_os_error().to_string()); + } + + Ok(()) + } + + /// Return the allocated memory as a slice of u8. + pub fn as_slice(&self) -> &[u8] { + unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) } + } + + /// Return the allocated memory as a mutable slice of u8. + pub fn as_mut_slice(&mut self) -> &mut [u8] { + unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, self.len) } + } + + /// Return the allocated memory as a pointer to u8. + pub fn as_ptr(&self) -> *const u8 { + self.ptr as *const u8 + } + + /// Return the allocated memory as a mutable pointer to u8. + pub fn as_mut_ptr(&mut self) -> *mut u8 { + self.ptr as *mut u8 + } + + /// Return the length of the allocated memory. + pub fn len(&self) -> usize { + self.len + } + + /// Return whether any memory has been allocated. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +impl Drop for Mmap { + #[cfg(not(target_os = "windows"))] + fn drop(&mut self) { + if self.len != 0 { + let r = unsafe { libc::munmap(self.ptr as *mut libc::c_void, self.len) }; + assert_eq!(r, 0, "munmap failed: {}", io::Error::last_os_error()); + } + } + + #[cfg(target_os = "windows")] + fn drop(&mut self) { + if self.len != 0 { + use winapi::ctypes::c_void; + use winapi::um::memoryapi::VirtualFree; + use winapi::um::winnt::MEM_RELEASE; + let r = unsafe { VirtualFree(self.ptr as *mut c_void, 0, MEM_RELEASE) }; + assert_ne!(r, 0); + } + } +} + +fn _assert() { + fn _assert_send_sync<T: Send + Sync>() {} + _assert_send_sync::<Mmap>(); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_round_up_to_page_size() { + assert_eq!(round_up_to_page_size(0, 4096), 0); + assert_eq!(round_up_to_page_size(1, 4096), 4096); + assert_eq!(round_up_to_page_size(4096, 4096), 4096); + assert_eq!(round_up_to_page_size(4097, 4096), 8192); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +
+//! Implement a registry of function signatures, for fast indirect call +//! signature checking. + +use crate::vmcontext::VMSharedSignatureIndex; +use more_asserts::{assert_lt, debug_assert_lt}; +use std::collections::{hash_map, HashMap}; +use std::convert::TryFrom; +use std::sync::RwLock; +use wasmtime_environ::ir; + +/// WebAssembly requires that the caller and callee signatures in an indirect +/// call must match. To implement this efficiently, keep a registry of all +/// signatures, shared by all instances, so that call sites can just do an +/// index comparison. +#[derive(Debug)] +pub struct SignatureRegistry { + // This structure is stored in a `Compiler` and is intended to be shared + // across many instances. Ideally instances can themselves be sent across + // threads, and ideally we can compile across many threads. As a result we + // use interior mutability here with a lock to avoid having callers to + // externally synchronize calls to compilation. + inner: RwLock<Inner>, +} + +#[derive(Debug, Default)] +struct Inner { + signature2index: HashMap<ir::Signature, VMSharedSignatureIndex>, + index2signature: HashMap<VMSharedSignatureIndex, ir::Signature>, +} + +impl SignatureRegistry { + /// Create a new `SignatureRegistry`. + pub fn new() -> Self { + Self { + inner: Default::default(), + } + } + + /// Register a signature and return its unique index. + pub fn register(&self, sig: &ir::Signature) -> VMSharedSignatureIndex { + let mut inner = self.inner.write().unwrap(); + let len = inner.signature2index.len(); + match inner.signature2index.entry(sig.clone()) { + hash_map::Entry::Occupied(entry) => *entry.get(), + hash_map::Entry::Vacant(entry) => { + // Keep `signature_hash` len under 2**32 -- VMSharedSignatureIndex::new(std::u32::MAX) + // is reserved for VMSharedSignatureIndex::default(). + debug_assert_lt!( + len, + std::u32::MAX as usize, + "Invariant check: signature_hash.len() < std::u32::MAX" + ); + let sig_id = VMSharedSignatureIndex::new(u32::try_from(len).unwrap()); + entry.insert(sig_id); + inner.index2signature.insert(sig_id, sig.clone()); + sig_id + } + } + } + + /// Looks up a shared signature index within this registry. + /// + /// Note that for this operation to be semantically correct the `idx` must + /// have previously come from a call to `register` of this same object. + pub fn lookup(&self, idx: VMSharedSignatureIndex) -> Option<ir::Signature> { + self.inner + .read() + .unwrap() + .index2signature + .get(&idx) + .cloned() + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +
+//! Interface to low-level signal-handling mechanisms. + +use std::sync::Once; + +extern "C" { + fn EnsureEagerSignalHandlers() -> libc::c_int; +} + +/// This function performs the low-overhead signal handler initialization that +/// we want to do eagerly to ensure a more-deterministic global process state. +/// +/// This is especially relevant for signal handlers since handler ordering +/// depends on installation order: the wasm signal handler must run *before* +/// the other crash handlers and since POSIX signal handlers work LIFO, this +/// function needs to be called at the end of the startup process, after other +/// handlers have been installed. This function can thus be called multiple +/// times, having no effect after the first call. +pub fn init() { + static INIT: Once = Once::new(); + INIT.call_once(real_init); +} + +fn real_init() { + // This is a really weird and unfortunate function call. For all the gory + // details see #829, but the tl;dr; is that in a trap handler we have 2 + // pages of stack space on Linux, and calling into libunwind which triggers + // the dynamic loader blows the stack. + // + // This is a dumb hack to work around this system-specific issue by + // capturing a backtrace once in the lifetime of a process to ensure that + // when we capture a backtrace in the trap handler all caches are primed, + // aka the dynamic loader has resolved all the relevant symbols. + drop(backtrace::Backtrace::new_unresolved()); + + if unsafe { EnsureEagerSignalHandlers() == 0 } { + panic!("failed to install signal handlers"); + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +
+//! Memory management for tables. +//! +//! `Table` is to WebAssembly tables what `LinearMemory` is to WebAssembly linear memories. + +use crate::vmcontext::{VMCallerCheckedAnyfunc, VMTableDefinition}; +use std::cell::RefCell; +use std::convert::{TryFrom, TryInto}; +use wasmtime_environ::wasm::TableElementType; +use wasmtime_environ::{TablePlan, TableStyle}; + +/// A table instance. +#[derive(Debug)] +pub struct Table { + vec: RefCell<Vec<VMCallerCheckedAnyfunc>>, + maximum: Option<u32>, +} + +impl Table { + /// Create a new table instance with specified minimum and maximum number of elements. + pub fn new(plan: &TablePlan) -> Self { + match plan.table.ty { + TableElementType::Func => (), + TableElementType::Val(ty) => { + unimplemented!("tables of types other than anyfunc ({})", ty) + } + }; + match plan.style { + TableStyle::CallerChecksSignature => Self { + vec: RefCell::new(vec![ + VMCallerCheckedAnyfunc::default(); + usize::try_from(plan.table.minimum).unwrap() + ]), + maximum: plan.table.maximum, + }, + } + } + + /// Returns the number of allocated elements. + pub fn size(&self) -> u32 { + self.vec.borrow().len().try_into().unwrap() + } + + /// Grow table by the specified amount of elements. + /// + /// Returns `None` if table can't be grown by the specified amount + /// of elements. + pub fn grow(&self, delta: u32) -> Option<u32> { + let new_len = match self.size().checked_add(delta) { + Some(len) => { + if let Some(max) = self.maximum { + if len > max { + return None; + } + } + len + } + None => { + return None; + } + }; + self.vec.borrow_mut().resize( + usize::try_from(new_len).unwrap(), + VMCallerCheckedAnyfunc::default(), + ); + Some(new_len) + } + + /// Get reference to the specified element. + /// + /// Returns `None` if the index is out of bounds. + pub fn get(&self, index: u32) -> Option<VMCallerCheckedAnyfunc> { + self.vec.borrow().get(index as usize).cloned() + } + + /// Set reference to the specified element. + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + pub fn set(&self, index: u32, func: VMCallerCheckedAnyfunc) -> Result<(), ()> { + match self.vec.borrow_mut().get_mut(index as usize) { + Some(slot) => { + *slot = func; + Ok(()) + } + None => Err(()), + } + } + + /// Return a `VMTableDefinition` for exposing the table to compiled wasm code. + pub fn vmtable(&self) -> VMTableDefinition { + let mut vec = self.vec.borrow_mut(); + VMTableDefinition { + base: vec.as_mut_ptr() as *mut u8, + current_elements: vec.len().try_into().unwrap(), + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +
+use std::collections::{BTreeMap, HashMap}; +use std::fmt; +use std::sync::{Arc, RwLock}; +use wasmtime_environ::ir; + +/// The registry maintains descriptions of traps in currently allocated functions. +#[derive(Default)] +pub struct TrapRegistry { + // This data structure is intended to be safe to use across many threads + // since this is stored inside of a `Compiler` which, eventually, will be + // used across many threads. To that end this is internally use an `Arc` + // plus an `RwLock`. + // + // The problem that this data structure is solving is that when a + // segfault/illegal instruction happens we need to answer "given this + // hardware program counter what is the wasm reason this trap is being + // raised"? + // + // The way this is answered here is done to minimize the amount of + // synchronization (in theory) and have something like so: + // + // * Each module bulk-registers a list of in-memory pc addresses that have + // traps. We assume that the range of traps for each module are always + // disjoint. + // * Each key in this `BTreeMap` is the highest trapping address and the + // value contains the lowest address as well as all the individual + // addresses in their own `HashMap`. + // * Registration then looks by calculating the start/end and inserting + // into this map (with some assertions about disjointed-ness) + // * Lookup is done in two layers. First we find the corresponding entry + // in the map and verify that a program counter falls in the start/end + // range. Next we look up the address in the `traps` hash map below. + // + // The `register_traps` function works by returning an RAII guard that owns + // a handle to this `Arc` as well, and when that type is dropped it will + // automatically remove all trap information from this `ranges` list. + ranges: Arc<RwLock<BTreeMap<usize, TrapGroup>>>, +} + +#[derive(Debug)] +struct TrapGroup { + /// The lowest key in the `trap` field. + /// + /// This represents the start of the range of this group of traps, and the + /// end of the range for this group of traps is stored as the key in the + /// `ranges` struct above in `TrapRegistry`. + start: usize, + + /// All known traps in this group, mapped from program counter to the + /// description of the trap itself. + traps: HashMap<usize, TrapDescription>, +} + +/// RAII structure returned from `TrapRegistry::register_trap` to unregister +/// trap information on drop. +#[derive(Clone)] +pub struct TrapRegistration { + ranges: Arc<RwLock<BTreeMap<usize, TrapGroup>>>, + end: Option<usize>, +} + +/// Description of a trap. +#[derive(Clone, Copy, PartialEq, Debug)] +pub struct TrapDescription { + /// Location of the trap in source binary module. + pub source_loc: ir::SourceLoc, + /// Code of the trap. + pub trap_code: ir::TrapCode, +} + +impl fmt::Display for TrapDescription { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "wasm trap: {}, source location: {}", + trap_code_to_expected_string(self.trap_code), + self.source_loc + ) + } +} + +fn trap_code_to_expected_string(trap_code: ir::TrapCode) -> String { + use ir::TrapCode::*; + match trap_code { + StackOverflow => "call stack exhausted".to_string(), + HeapOutOfBounds => "out of bounds memory access".to_string(), + TableOutOfBounds => "undefined element".to_string(), + OutOfBounds => "out of bounds".to_string(), // Note: not covered by the test suite + IndirectCallToNull => "uninitialized element".to_string(), + BadSignature => "indirect call type mismatch".to_string(), + IntegerOverflow => "integer overflow".to_string(), + IntegerDivisionByZero => "integer divide by zero".to_string(), + BadConversionToInteger => "invalid conversion to integer".to_string(), + UnreachableCodeReached => "unreachable".to_string(), + Interrupt => "interrupt".to_string(), // Note: not covered by the test suite + User(x) => format!("user trap {}", x), // Note: not covered by the test suite + } +} + +impl TrapRegistry { + /// Registers a list of traps. + /// + /// Returns a RAII guard that deregisters all traps when dropped. + pub fn register_traps( + &self, + list: impl IntoIterator<Item = (usize, ir::SourceLoc, ir::TrapCode)>, + ) -> TrapRegistration { + let mut start = usize::max_value(); + let mut end = 0; + let mut traps = HashMap::new(); + for (addr, source_loc, trap_code) in list.into_iter() { + traps.insert( + addr, + TrapDescription { + source_loc, + trap_code, + }, + ); + if addr < start { + start = addr; + } + if addr > end { + end = addr; + } + } + if traps.len() == 0 { + return TrapRegistration { + ranges: self.ranges.clone(), + end: None, + }; + } + let mut ranges = self.ranges.write().unwrap(); + + // Sanity check that no other group of traps overlaps with our + // registration... + if let Some((_, prev)) = ranges.range(end..).next() { + assert!(prev.start > end); + } + if let Some((prev_end, _)) = ranges.range(..=start).next_back() { + assert!(*prev_end < start); + } + + // ... and then register ourselves + assert!(ranges.insert(end, TrapGroup { start, traps }).is_none()); + TrapRegistration { + ranges: self.ranges.clone(), + end: Some(end), + } + } +} + +impl TrapRegistration { + /// Gets a trap description at given address. + pub fn get_trap(&self, address: usize) -> Option<TrapDescription> { + let ranges = self.ranges.read().ok()?; + let (end, group) = ranges.range(address..).next()?; + if group.start <= address && address <= *end { + group.traps.get(&address).copied() + } else { + None + } + } +} + +impl Drop for TrapRegistration { + fn drop(&mut self) { + if let Some(end) = self.end { + if let Ok(mut ranges) = self.ranges.write() { + ranges.remove(&end); + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +
+//! WebAssembly trap handling, which is built on top of the lower-level +//! signalhandling mechanisms. + +use crate::instance::{InstanceHandle, SignalHandler}; +use crate::trap_registry::TrapDescription; +use crate::vmcontext::{VMContext, VMFunctionBody}; +use backtrace::Backtrace; +use std::any::Any; +use std::cell::Cell; +use std::error::Error; +use std::fmt; +use std::mem; +use std::ptr; +use wasmtime_environ::ir; + +extern "C" { + fn RegisterSetjmp( + jmp_buf: *mut *const u8, + callback: extern "C" fn(*mut u8), + payload: *mut u8, + ) -> i32; + fn Unwind(jmp_buf: *const u8) -> !; +} + +cfg_if::cfg_if! { + if #[cfg(unix)] { + #[no_mangle] + pub unsafe extern "C" fn HandleTrap( + pc: *mut u8, + signum: libc::c_int, + siginfo: *mut libc::siginfo_t, + context: *mut libc::c_void, + ) -> *const u8 { + tls::with(|info| { + match info { + Some(info) => info.handle_trap(pc, false, |handler| handler(signum, siginfo, context)), + None => ptr::null(), + } + }) + } + } else if #[cfg(target_os = "windows")] { + use winapi::um::winnt::PEXCEPTION_POINTERS; + use winapi::um::minwinbase::EXCEPTION_STACK_OVERFLOW; + + #[no_mangle] + pub unsafe extern "C" fn HandleTrap( + pc: *mut u8, + exception_info: PEXCEPTION_POINTERS + ) -> *const u8 { + tls::with(|info| { + let reset_guard_page = (*(*exception_info).ExceptionRecord).ExceptionCode == EXCEPTION_STACK_OVERFLOW; + match info { + Some(info) => info.handle_trap(pc, reset_guard_page, |handler| handler(exception_info)), + None => ptr::null(), + } + }) + } + } +} + +/// Raises a user-defined trap immediately. +/// +/// This function performs as-if a wasm trap was just executed, only the trap +/// has a dynamic payload associated with it which is user-provided. This trap +/// payload is then returned from `wasmtime_call` an `wasmtime_call_trampoline` +/// below. +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `wasmtime_call` or +/// `wasmtime_call_trampoline` must have been previously called. +pub unsafe fn raise_user_trap(data: Box<dyn Error + Send + Sync>) -> ! { + tls::with(|info| info.unwrap().unwind_with(UnwindReason::UserTrap(data))) +} + +/// Carries a Rust panic across wasm code and resumes the panic on the other +/// side. +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `wasmtime_call` or +/// `wasmtime_call_trampoline` must have been previously called. +pub unsafe fn resume_panic(payload: Box<dyn Any + Send>) -> ! { + tls::with(|info| info.unwrap().unwind_with(UnwindReason::Panic(payload))) +} + +#[cfg(target_os = "windows")] +fn reset_guard_page() { + extern "C" { + fn _resetstkoflw() -> winapi::ctypes::c_int; + } + + // We need to restore guard page under stack to handle future stack overflows properly. + // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/resetstkoflw?view=vs-2019 + if unsafe { _resetstkoflw() } == 0 { + panic!("failed to restore stack guard page"); + } +} + +#[cfg(not(target_os = "windows"))] +fn reset_guard_page() {} + +/// Stores trace message with backtrace. +#[derive(Debug)] +pub enum Trap { + /// A user-raised trap through `raise_user_trap`. + User(Box<dyn Error + Send + Sync>), + /// A wasm-originating trap from wasm code itself. + Wasm { + /// What sort of trap happened, as well as where in the original wasm module + /// it happened. + desc: TrapDescription, + /// Native stack backtrace at the time the trap occurred + backtrace: Backtrace, + }, +} + +impl fmt::Display for Trap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Trap::User(user) => user.fmt(f), + Trap::Wasm { desc, .. } => desc.fmt(f), + } + } +} + +impl std::error::Error for Trap {} + +/// Call the wasm function pointed to by `callee`. +/// +/// * `vmctx` - the callee vmctx argument +/// * `caller_vmctx` - the caller vmctx argument +/// * `trampoline` - the jit-generated trampoline whose ABI takes 4 values, the +/// callee vmctx, the caller vmctx, the `callee` argument below, and then the +/// `values_vec` argument. +/// * `callee` - the third argument to the `trampoline` function +/// * `values_vec` - points to a buffer which holds the incoming arguments, and to +/// which the outgoing return values will be written. +/// +/// Wildly unsafe because it calls raw function pointers and reads/writes raw +/// function pointers. +pub unsafe fn wasmtime_call_trampoline( + vmctx: *mut VMContext, + caller_vmctx: *mut VMContext, + trampoline: *const VMFunctionBody, + callee: *const VMFunctionBody, + values_vec: *mut u8, +) -> Result<(), Trap> { + catch_traps(vmctx, || { + mem::transmute::< + _, + extern "C" fn(*mut VMContext, *mut VMContext, *const VMFunctionBody, *mut u8), + >(trampoline)(vmctx, caller_vmctx, callee, values_vec) + }) +} + +/// Catches any wasm traps that happen within the execution of `closure`, +/// returning them as a `Result`. +/// +/// Highly unsafe since `closure` won't have any dtors run. +pub unsafe fn catch_traps<F>(vmctx: *mut VMContext, mut closure: F) -> Result<(), Trap> +where + F: FnMut(), +{ + return CallThreadState::new(vmctx).with(|cx| { + RegisterSetjmp( + cx.jmp_buf.as_ptr(), + call_closure::<F>, + &mut closure as *mut F as *mut u8, + ) + }); + + extern "C" fn call_closure<F>(payload: *mut u8) + where + F: FnMut(), + { + unsafe { (*(payload as *mut F))() } + } +} + +/// Temporary state stored on the stack which is registered in the `tls` module +/// below for calls into wasm. +pub struct CallThreadState { + unwind: Cell<UnwindReason>, + jmp_buf: Cell<*const u8>, + reset_guard_page: Cell<bool>, + prev: Option<*const CallThreadState>, + vmctx: *mut VMContext, +} + +enum UnwindReason { + None, + Panic(Box<dyn Any + Send>), + UserTrap(Box<dyn Error + Send + Sync>), + Trap { backtrace: Backtrace, pc: usize }, +} + +impl CallThreadState { + fn new(vmctx: *mut VMContext) -> CallThreadState { + CallThreadState { + unwind: Cell::new(UnwindReason::None), + vmctx, + jmp_buf: Cell::new(ptr::null()), + reset_guard_page: Cell::new(false), + prev: None, + } + } + + fn with(mut self, closure: impl FnOnce(&CallThreadState) -> i32) -> Result<(), Trap> { + tls::with(|prev| { + self.prev = prev.map(|p| p as *const _); + let ret = tls::set(&self, || closure(&self)); + match self.unwind.replace(UnwindReason::None) { + UnwindReason::None => { + debug_assert_eq!(ret, 1); + Ok(()) + } + UnwindReason::UserTrap(data) => { + debug_assert_eq!(ret, 0); + Err(Trap::User(data)) + } + UnwindReason::Trap { backtrace, pc } => { + debug_assert_eq!(ret, 0); + let instance = unsafe { InstanceHandle::from_vmctx(self.vmctx) }; + + Err(Trap::Wasm { + desc: instance + .instance() + .trap_registration + .get_trap(pc) + .unwrap_or_else(|| TrapDescription { + source_loc: ir::SourceLoc::default(), + trap_code: ir::TrapCode::StackOverflow, + }), + backtrace, + }) + } + UnwindReason::Panic(panic) => { + debug_assert_eq!(ret, 0); + std::panic::resume_unwind(panic) + } + } + }) + } + + fn any_instance(&self, func: impl Fn(&InstanceHandle) -> bool) -> bool { + unsafe { + if func(&InstanceHandle::from_vmctx(self.vmctx)) { + return true; + } + match self.prev { + Some(prev) => (*prev).any_instance(func), + None => false, + } + } + } + + fn unwind_with(&self, reason: UnwindReason) -> ! { + self.unwind.replace(reason); + unsafe { + Unwind(self.jmp_buf.get()); + } + } + + /// Trap handler using our thread-local state. + /// + /// * `pc` - the program counter the trap happened at + /// * `reset_guard_page` - whether or not to reset the guard page, + /// currently Windows specific + /// * `call_handler` - a closure used to invoke the platform-specific + /// signal handler for each instance, if available. + /// + /// Attempts to handle the trap if it's a wasm trap. Returns a few + /// different things: + /// + /// * null - the trap didn't look like a wasm trap and should continue as a + /// trap + /// * 1 as a pointer - the trap was handled by a custom trap handler on an + /// instance, and the trap handler should quickly return. + /// * a different pointer - a jmp_buf buffer to longjmp to, meaning that + /// the wasm trap was succesfully handled. + fn handle_trap( + &self, + pc: *const u8, + reset_guard_page: bool, + call_handler: impl Fn(&SignalHandler) -> bool, + ) -> *const u8 { + // First up see if any instance registered has a custom trap handler, + // in which case run them all. If anything handles the trap then we + // return that the trap was handled. + if self.any_instance(|i| { + let handler = match i.instance().signal_handler.replace(None) { + Some(handler) => handler, + None => return false, + }; + let result = call_handler(&handler); + i.instance().signal_handler.set(Some(handler)); + return result; + }) { + return 1 as *const _; + } + + // TODO: stack overflow can happen at any random time (i.e. in malloc() + // in memory.grow) and it's really hard to determine if the cause was + // stack overflow and if it happened in WebAssembly module. + // + // So, let's assume that any untrusted code called from WebAssembly + // doesn't trap. Then, if we have called some WebAssembly code, it + // means the trap is stack overflow. + if self.jmp_buf.get().is_null() { + return ptr::null(); + } + let backtrace = Backtrace::new_unresolved(); + self.reset_guard_page.set(reset_guard_page); + self.unwind.replace(UnwindReason::Trap { + backtrace, + pc: pc as usize, + }); + self.jmp_buf.get() + } +} + +impl Drop for CallThreadState { + fn drop(&mut self) { + if self.reset_guard_page.get() { + reset_guard_page(); + } + } +} + +// A private inner module for managing the TLS state that we require across +// calls in wasm. The WebAssembly code is called from C++ and then a trap may +// happen which requires us to read some contextual state to figure out what to +// do with the trap. This `tls` module is used to persist that information from +// the caller to the trap site. +mod tls { + use super::CallThreadState; + use std::cell::Cell; + use std::ptr; + + thread_local!(static PTR: Cell<*const CallThreadState> = Cell::new(ptr::null())); + + /// Configures thread local state such that for the duration of the + /// execution of `closure` any call to `with` will yield `ptr`, unless this + /// is recursively called again. + pub fn set<R>(ptr: &CallThreadState, closure: impl FnOnce() -> R) -> R { + struct Reset<'a, T: Copy>(&'a Cell<T>, T); + + impl<T: Copy> Drop for Reset<'_, T> { + fn drop(&mut self) { + self.0.set(self.1); + } + } + + PTR.with(|p| { + let _r = Reset(p, p.replace(ptr)); + closure() + }) + } + + /// Returns the last pointer configured with `set` above. Panics if `set` + /// has not been previously called. + pub fn with<R>(closure: impl FnOnce(Option<&CallThreadState>) -> R) -> R { + PTR.with(|ptr| { + let p = ptr.get(); + unsafe { closure(if p.is_null() { None } else { Some(&*p) }) } + }) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +
+//! This file declares `VMContext` and several related structs which contain +//! fields that compiled wasm code accesses directly. + +use crate::instance::Instance; +use std::any::Any; +use std::{ptr, u32}; +use wasmtime_environ::BuiltinFunctionIndex; + +/// An imported function. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMFunctionImport { + /// A pointer to the imported function body. + pub body: *const VMFunctionBody, + + /// A pointer to the `VMContext` that owns the function. + pub vmctx: *mut VMContext, +} + +#[cfg(test)] +mod test_vmfunction_import { + use super::VMFunctionImport; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmfunction_import_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMFunctionImport>(), + usize::from(offsets.size_of_vmfunction_import()) + ); + assert_eq!( + offset_of!(VMFunctionImport, body), + usize::from(offsets.vmfunction_import_body()) + ); + assert_eq!( + offset_of!(VMFunctionImport, vmctx), + usize::from(offsets.vmfunction_import_vmctx()) + ); + } +} + +/// A placeholder byte-sized type which is just used to provide some amount of type +/// safety when dealing with pointers to JIT-compiled function bodies. Note that it's +/// deliberately not Copy, as we shouldn't be carelessly copying function body bytes +/// around. +#[repr(C)] +pub struct VMFunctionBody(u8); + +#[cfg(test)] +mod test_vmfunction_body { + use super::VMFunctionBody; + use std::mem::size_of; + + #[test] + fn check_vmfunction_body_offsets() { + assert_eq!(size_of::<VMFunctionBody>(), 1); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly table +/// imported from another instance. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMTableImport { + /// A pointer to the imported table description. + pub from: *mut VMTableDefinition, + + /// A pointer to the `VMContext` that owns the table description. + pub vmctx: *mut VMContext, +} + +#[cfg(test)] +mod test_vmtable_import { + use super::VMTableImport; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmtable_import_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMTableImport>(), + usize::from(offsets.size_of_vmtable_import()) + ); + assert_eq!( + offset_of!(VMTableImport, from), + usize::from(offsets.vmtable_import_from()) + ); + assert_eq!( + offset_of!(VMTableImport, vmctx), + usize::from(offsets.vmtable_import_vmctx()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly linear +/// memory imported from another instance. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMMemoryImport { + /// A pointer to the imported memory description. + pub from: *mut VMMemoryDefinition, + + /// A pointer to the `VMContext` that owns the memory description. + pub vmctx: *mut VMContext, +} + +#[cfg(test)] +mod test_vmmemory_import { + use super::VMMemoryImport; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmmemory_import_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMMemoryImport>(), + usize::from(offsets.size_of_vmmemory_import()) + ); + assert_eq!( + offset_of!(VMMemoryImport, from), + usize::from(offsets.vmmemory_import_from()) + ); + assert_eq!( + offset_of!(VMMemoryImport, vmctx), + usize::from(offsets.vmmemory_import_vmctx()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly global +/// variable imported from another instance. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMGlobalImport { + /// A pointer to the imported global variable description. + pub from: *mut VMGlobalDefinition, +} + +#[cfg(test)] +mod test_vmglobal_import { + use super::VMGlobalImport; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmglobal_import_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMGlobalImport>(), + usize::from(offsets.size_of_vmglobal_import()) + ); + assert_eq!( + offset_of!(VMGlobalImport, from), + usize::from(offsets.vmglobal_import_from()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly linear +/// memory defined within the instance, namely the start address and the +/// size in bytes. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMMemoryDefinition { + /// The start address. + pub base: *mut u8, + + /// The current logical size of this linear memory in bytes. + pub current_length: usize, +} + +#[cfg(test)] +mod test_vmmemory_definition { + use super::VMMemoryDefinition; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmmemory_definition_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMMemoryDefinition>(), + usize::from(offsets.size_of_vmmemory_definition()) + ); + assert_eq!( + offset_of!(VMMemoryDefinition, base), + usize::from(offsets.vmmemory_definition_base()) + ); + assert_eq!( + offset_of!(VMMemoryDefinition, current_length), + usize::from(offsets.vmmemory_definition_current_length()) + ); + /* TODO: Assert that the size of `current_length` matches. + assert_eq!( + size_of::<VMMemoryDefinition::current_length>(), + usize::from(offsets.size_of_vmmemory_definition_current_length()) + ); + */ + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly table +/// defined within the instance. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMTableDefinition { + /// Pointer to the table data. + pub base: *mut u8, + + /// The current number of elements in the table. + pub current_elements: u32, +} + +#[cfg(test)] +mod test_vmtable_definition { + use super::VMTableDefinition; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmtable_definition_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMTableDefinition>(), + usize::from(offsets.size_of_vmtable_definition()) + ); + assert_eq!( + offset_of!(VMTableDefinition, base), + usize::from(offsets.vmtable_definition_base()) + ); + assert_eq!( + offset_of!(VMTableDefinition, current_elements), + usize::from(offsets.vmtable_definition_current_elements()) + ); + } +} + +/// The storage for a WebAssembly global defined within the instance. +/// +/// TODO: Pack the globals more densely, rather than using the same size +/// for every type. +#[derive(Debug, Copy, Clone)] +#[repr(C, align(16))] +pub struct VMGlobalDefinition { + storage: [u8; 16], + // If more elements are added here, remember to add offset_of tests below! +} + +#[cfg(test)] +mod test_vmglobal_definition { + use super::VMGlobalDefinition; + use more_asserts::assert_ge; + use std::mem::{align_of, size_of}; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmglobal_definition_alignment() { + assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i32>()); + assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i64>()); + assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f32>()); + assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f64>()); + assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<[u8; 16]>()); + } + + #[test] + fn check_vmglobal_definition_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMGlobalDefinition>(), + usize::from(offsets.size_of_vmglobal_definition()) + ); + } + + #[test] + fn check_vmglobal_begins_aligned() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!(offsets.vmctx_globals_begin() % 16, 0); + } +} + +impl VMGlobalDefinition { + /// Construct a `VMGlobalDefinition`. + pub fn new() -> Self { + Self { storage: [0; 16] } + } + + /// Return a reference to the value as an i32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_i32(&self) -> &i32 { + &*(self.storage.as_ref().as_ptr() as *const i32) + } + + /// Return a mutable reference to the value as an i32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_i32_mut(&mut self) -> &mut i32 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut i32) + } + + /// Return a reference to the value as a u32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u32(&self) -> &u32 { + &*(self.storage.as_ref().as_ptr() as *const u32) + } + + /// Return a mutable reference to the value as an u32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u32_mut(&mut self) -> &mut u32 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut u32) + } + + /// Return a reference to the value as an i64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_i64(&self) -> &i64 { + &*(self.storage.as_ref().as_ptr() as *const i64) + } + + /// Return a mutable reference to the value as an i64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_i64_mut(&mut self) -> &mut i64 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut i64) + } + + /// Return a reference to the value as an u64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u64(&self) -> &u64 { + &*(self.storage.as_ref().as_ptr() as *const u64) + } + + /// Return a mutable reference to the value as an u64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u64_mut(&mut self) -> &mut u64 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut u64) + } + + /// Return a reference to the value as an f32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f32(&self) -> &f32 { + &*(self.storage.as_ref().as_ptr() as *const f32) + } + + /// Return a mutable reference to the value as an f32. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f32_mut(&mut self) -> &mut f32 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut f32) + } + + /// Return a reference to the value as f32 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f32_bits(&self) -> &u32 { + &*(self.storage.as_ref().as_ptr() as *const u32) + } + + /// Return a mutable reference to the value as f32 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f32_bits_mut(&mut self) -> &mut u32 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut u32) + } + + /// Return a reference to the value as an f64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f64(&self) -> &f64 { + &*(self.storage.as_ref().as_ptr() as *const f64) + } + + /// Return a mutable reference to the value as an f64. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f64_mut(&mut self) -> &mut f64 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut f64) + } + + /// Return a reference to the value as f64 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f64_bits(&self) -> &u64 { + &*(self.storage.as_ref().as_ptr() as *const u64) + } + + /// Return a mutable reference to the value as f64 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_f64_bits_mut(&mut self) -> &mut u64 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut u64) + } + + /// Return a reference to the value as an u128. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u128(&self) -> &u128 { + &*(self.storage.as_ref().as_ptr() as *const u128) + } + + /// Return a mutable reference to the value as an u128. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u128_mut(&mut self) -> &mut u128 { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut u128) + } + + /// Return a reference to the value as u128 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u128_bits(&self) -> &[u8; 16] { + &*(self.storage.as_ref().as_ptr() as *const [u8; 16]) + } + + /// Return a mutable reference to the value as u128 bits. + #[allow(clippy::cast_ptr_alignment)] + pub unsafe fn as_u128_bits_mut(&mut self) -> &mut [u8; 16] { + &mut *(self.storage.as_mut().as_mut_ptr() as *mut [u8; 16]) + } +} + +/// An index into the shared signature registry, usable for checking signatures +/// at indirect calls. +#[repr(C)] +#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)] +pub struct VMSharedSignatureIndex(u32); + +#[cfg(test)] +mod test_vmshared_signature_index { + use super::VMSharedSignatureIndex; + use std::mem::size_of; + use wasmtime_environ::{Module, TargetSharedSignatureIndex, VMOffsets}; + + #[test] + fn check_vmshared_signature_index() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMSharedSignatureIndex>(), + usize::from(offsets.size_of_vmshared_signature_index()) + ); + } + + #[test] + fn check_target_shared_signature_index() { + assert_eq!( + size_of::<VMSharedSignatureIndex>(), + size_of::<TargetSharedSignatureIndex>() + ); + } +} + +impl VMSharedSignatureIndex { + /// Create a new `VMSharedSignatureIndex`. + pub fn new(value: u32) -> Self { + Self(value) + } +} + +impl Default for VMSharedSignatureIndex { + fn default() -> Self { + Self::new(u32::MAX) + } +} + +/// The VM caller-checked "anyfunc" record, for caller-side signature checking. +/// It consists of the actual function pointer and a signature id to be checked +/// by the caller. +#[derive(Debug, Clone)] +#[repr(C)] +pub struct VMCallerCheckedAnyfunc { + /// Function body. + pub func_ptr: *const VMFunctionBody, + /// Function signature id. + pub type_index: VMSharedSignatureIndex, + /// Function `VMContext`. + pub vmctx: *mut VMContext, + // If more elements are added here, remember to add offset_of tests below! +} + +#[cfg(test)] +mod test_vmcaller_checked_anyfunc { + use super::VMCallerCheckedAnyfunc; + use memoffset::offset_of; + use std::mem::size_of; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vmcaller_checked_anyfunc_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMCallerCheckedAnyfunc>(), + usize::from(offsets.size_of_vmcaller_checked_anyfunc()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, func_ptr), + usize::from(offsets.vmcaller_checked_anyfunc_func_ptr()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, type_index), + usize::from(offsets.vmcaller_checked_anyfunc_type_index()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, vmctx), + usize::from(offsets.vmcaller_checked_anyfunc_vmctx()) + ); + } +} + +impl Default for VMCallerCheckedAnyfunc { + fn default() -> Self { + Self { + func_ptr: ptr::null_mut(), + type_index: Default::default(), + vmctx: ptr::null_mut(), + } + } +} + +/// An array that stores addresses of builtin functions. We translate code +/// to use indirect calls. This way, we don't have to patch the code. +#[repr(C)] +pub struct VMBuiltinFunctionsArray { + ptrs: [usize; Self::len()], +} + +impl VMBuiltinFunctionsArray { + pub const fn len() -> usize { + BuiltinFunctionIndex::builtin_functions_total_number() as usize + } + + pub fn initialized() -> Self { + use crate::libcalls::*; + let mut ptrs = [0; Self::len()]; + ptrs[BuiltinFunctionIndex::get_memory32_grow_index().index() as usize] = + wasmtime_memory32_grow as usize; + ptrs[BuiltinFunctionIndex::get_imported_memory32_grow_index().index() as usize] = + wasmtime_imported_memory32_grow as usize; + ptrs[BuiltinFunctionIndex::get_memory32_size_index().index() as usize] = + wasmtime_memory32_size as usize; + ptrs[BuiltinFunctionIndex::get_imported_memory32_size_index().index() as usize] = + wasmtime_imported_memory32_size as usize; + Self { ptrs } + } +} + +/// The storage for a WebAssembly invocation argument +/// +/// TODO: These could be packed more densely, rather than using the same size for every type. +#[derive(Debug, Copy, Clone)] +#[repr(C, align(16))] +pub struct VMInvokeArgument([u8; 16]); + +#[cfg(test)] +mod test_vm_invoke_argument { + use super::VMInvokeArgument; + use std::mem::{align_of, size_of}; + use wasmtime_environ::{Module, VMOffsets}; + + #[test] + fn check_vm_invoke_argument_alignment() { + assert_eq!(align_of::<VMInvokeArgument>(), 16); + } + + #[test] + fn check_vmglobal_definition_offsets() { + let module = Module::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module); + assert_eq!( + size_of::<VMInvokeArgument>(), + usize::from(offsets.size_of_vmglobal_definition()) + ); + } +} + +impl VMInvokeArgument { + /// Create a new invocation argument filled with zeroes + pub fn new() -> Self { + Self([0; 16]) + } +} + +/// The VM "context", which is pointed to by the `vmctx` arg in Cranelift. +/// This has information about globals, memories, tables, and other runtime +/// state associated with the current instance. +/// +/// The struct here is empty, as the sizes of these fields are dynamic, and +/// we can't describe them in Rust's type system. Sufficient memory is +/// allocated at runtime. +/// +/// TODO: We could move the globals into the `vmctx` allocation too. +#[derive(Debug)] +#[repr(C, align(16))] // align 16 since globals are aligned to that and contained inside +pub struct VMContext {} + +impl VMContext { + /// Return a mutable reference to the associated `Instance`. + /// + /// # Safety + /// This is unsafe because it doesn't work on just any `VMContext`, it must + /// be a `VMContext` allocated as part of an `Instance`. + #[allow(clippy::cast_ptr_alignment)] + pub(crate) unsafe fn instance(&self) -> &Instance { + &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *const Instance) + } + + /// Return a reference to the host state associated with this `Instance`. + /// + /// # Safety + /// This is unsafe because it doesn't work on just any `VMContext`, it must + /// be a `VMContext` allocated as part of an `Instance`. + pub unsafe fn host_state(&self) -> &dyn Any { + self.instance().host_state() + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +
+pub use wasmtime_rust_macro::wasmtime; + +// modules used by the macro +#[doc(hidden)] +pub mod __rt { + pub use anyhow; + pub use wasmtime; + pub use wasmtime_interface_types; + pub use wasmtime_wasi; + + use std::convert::{TryFrom, TryInto}; + use wasmtime_interface_types::Value; + + pub trait FromVecValue: Sized { + fn from(list: Vec<Value>) -> anyhow::Result<Self>; + } + + macro_rules! tuple { + ($(($($a:ident),*),)*) => ($( + impl<$($a: TryFrom<Value>),*> FromVecValue for ($($a,)*) + where $(anyhow::Error: From<$a::Error>,)* + { + #[allow(non_snake_case)] + fn from(list: Vec<Value>) -> anyhow::Result<Self> { + let mut iter = list.into_iter(); + $( + let $a = iter.next() + .ok_or_else(|| anyhow::format_err!("not enough values"))? + .try_into()?; + )* + if iter.next().is_some() { + anyhow::bail!("too many return values"); + } + Ok(($($a,)*)) + } + } + )*) + } + + tuple! { + (), + (A), + (A, B), + (A, B, C), + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +
+extern crate proc_macro; + +use proc_macro2::TokenStream; +use quote::quote; +use syn::spanned::Spanned; + +#[proc_macro_attribute] +pub fn wasmtime( + _attr: proc_macro::TokenStream, + item: proc_macro::TokenStream, +) -> proc_macro::TokenStream { + let item = syn::parse_macro_input!(item as syn::ItemTrait); + expand(item).unwrap_or_else(|e| e.to_compile_error()).into() +} + +fn expand(item: syn::ItemTrait) -> syn::Result<TokenStream> { + let definition = generate_struct(&item)?; + let load = generate_load(&item)?; + let methods = generate_methods(&item)?; + let name = &item.ident; + + Ok(quote! { + #definition + impl #name { + #load + #methods + } + }) +} + +fn generate_struct(item: &syn::ItemTrait) -> syn::Result<TokenStream> { + let vis = &item.vis; + let name = &item.ident; + let root = root(); + Ok(quote! { + #vis struct #name { + instance: #root::wasmtime::Instance, + data: #root::wasmtime_interface_types::ModuleData, + } + }) +} + +fn generate_load(item: &syn::ItemTrait) -> syn::Result<TokenStream> { + let vis = &item.vis; + let name = &item.ident; + let root = root(); + Ok(quote! { + #vis fn load_file(path: impl AsRef<std::path::Path>) -> #root::anyhow::Result<#name> { + Self::load_bytes(std::fs::read(path)?) + } + + #vis fn load_bytes(bytes: impl AsRef<[u8]>) -> #root::anyhow::Result<#name> { + use #root::wasmtime::{Config, Extern, Engine, Store, Instance, Module}; + use #root::anyhow::{bail, format_err}; + + let engine = Engine::new(Config::new().wasm_multi_value(true)); + let store = Store::new(&engine); + + let data = #root::wasmtime_interface_types::ModuleData::new(bytes.as_ref())?; + + let module = Module::new(&store, bytes.as_ref())?; + + let mut imports: Vec<Extern> = Vec::new(); + if let Some(module_name) = data.find_wasi_module_name() { + let wasi_cx = #root::wasmtime_wasi::WasiCtxBuilder::new().build()?; + let wasi = #root::wasmtime_wasi::Wasi::new(&store, wasi_cx); + for i in module.imports().iter() { + if i.module() != module_name { + bail!("unknown import module {}", i.module()); + } + if let Some(export) = wasi.get_export(i.name()) { + imports.push(export.clone().into()); + } else { + bail!("unknown import {}:{}", i.module(), i.name()) + } + } + } + let instance = + Instance::new(&module, &imports).map_err(|t| format_err!("instantiation trap: {:?}", t))?; + + Ok(#name { instance, data }) + } + }) +} + +fn generate_methods(item: &syn::ItemTrait) -> syn::Result<TokenStream> { + macro_rules! bail { + ($e:expr, $($fmt:tt)*) => ( + return Err(syn::Error::new($e.span(), format!($($fmt)*))); + ) + } + let mut result = TokenStream::new(); + let root = root(); + let vis = &item.vis; + + for item in item.items.iter() { + let method = match item { + syn::TraitItem::Method(f) => f, + other => bail!(other, "only methods are allowed"), + }; + if let Some(e) = &method.default { + bail!(e, "cannot specify an implementation of methods"); + } + if let Some(t) = &method.sig.constness { + bail!(t, "cannot be `const`"); + } + if let Some(t) = &method.sig.asyncness { + bail!(t, "cannot be `async`"); + } + match &method.sig.inputs.first() { + Some(syn::FnArg::Receiver(_)) => {} + Some(t) => bail!(t, "first arugment needs to be \"self\""), + None => bail!( + method.sig, + "trait method requires at least one argument which needs to be \"self\"" + ), + } + + let mut args = Vec::new(); + for arg in method.sig.inputs.iter() { + let arg = match arg { + syn::FnArg::Receiver(_) => continue, + syn::FnArg::Typed(arg) => arg, + }; + let ident = match &*arg.pat { + syn::Pat::Ident(i) => i, + other => bail!(other, "must use bare idents for arguments"), + }; + if let Some(t) = &ident.by_ref { + bail!(t, "arguments cannot bind by reference"); + } + if let Some(t) = &ident.mutability { + bail!(t, "arguments cannot be mutable"); + } + if let Some((_, t)) = &ident.subpat { + bail!(t, "arguments cannot have sub-bindings"); + } + let ident = &ident.ident; + args.push(quote! { + #root::wasmtime_interface_types::Value::from(#ident) + }); + } + + let convert_ret = match &method.sig.output { + syn::ReturnType::Default => { + quote! { + <() as #root::FromVecValue>::from(results) + } + } + syn::ReturnType::Type(_, ty) => match &**ty { + syn::Type::Tuple(..) => { + quote! { <#ty as #root::FromVecValue>::from(results) } + } + _ => { + quote! { <(#ty,) as #root::FromVecValue>::from(results).map(|t| t.0) } + } + }, + }; + + let sig = &method.sig; + let attrs = &method.attrs; + let name = &method.sig.ident; + + result.extend(quote! { + #(#attrs)* + #vis #sig { + let args = [ + #(#args),* + ]; + let results = self.data.invoke_export( + &self.instance, + stringify!(#name), + &args, + ).expect("wasm execution failed"); + #convert_ret.expect("failed to convert return type") + } + }); + } + + Ok(result) +} + +fn root() -> TokenStream { + quote! { wasmtime_rust::__rt } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +
+pub mod old; + +use wasi_common::hostcalls; + +pub use wasi_common::{WasiCtx, WasiCtxBuilder}; + +// Defines a `struct Wasi` with member fields and appropriate APIs for dealing +// with all the various WASI exports. +wig::define_wasi_struct!( + "snapshot" "wasi_snapshot_preview1" +); + +pub fn is_wasi_module(name: &str) -> bool { + // FIXME: this should be more conservative, but while WASI is in flux and + // we're figuring out how to support multiple revisions, this should do the + // trick. + name.starts_with("wasi") +} + +/// This is an internal structure used to acquire a handle on the caller's +/// wasm memory buffer. +/// +/// This exploits how we can implement `WasmTy` for ourselves locally even +/// though crates in general should not be doing that. This is a crate in +/// the wasmtime project, however, so we should be able to keep up with our own +/// changes. +/// +/// In general this type is wildly unsafe. We need to update the wasi crates to +/// probably work with more `wasmtime`-like APIs to grip with the unsafety +/// around dealing with caller memory. +struct WasiCallerMemory { + base: *mut u8, + len: usize, +} + +impl wasmtime::WasmTy for WasiCallerMemory { + type Abi = (); + + fn push(_dst: &mut Vec<wasmtime::ValType>) {} + + fn matches(_tys: impl Iterator<Item = wasmtime::ValType>) -> bool { + true + } + + fn from_abi(vmctx: *mut wasmtime_runtime::VMContext, _abi: ()) -> Self { + unsafe { + match wasmtime_runtime::InstanceHandle::from_vmctx(vmctx).lookup("memory") { + Some(wasmtime_runtime::Export::Memory { + definition, + vmctx: _, + memory: _, + }) => WasiCallerMemory { + base: (*definition).base, + len: (*definition).current_length, + }, + _ => WasiCallerMemory { + base: std::ptr::null_mut(), + len: 0, + }, + } + } + } + + fn into_abi(self) {} +} + +impl WasiCallerMemory { + unsafe fn get(&self) -> Result<&mut [u8], wasi_common::wasi::__wasi_errno_t> { + if self.base.is_null() { + Err(wasi_common::wasi::__WASI_ERRNO_INVAL) + } else { + Ok(std::slice::from_raw_parts_mut(self.base, self.len)) + } + } +} +
1
++pub mod snapshot_0; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +
+use wasi_common::old::snapshot_0::hostcalls; +use wasi_common::old::snapshot_0::WasiCtx; + +// Defines a `struct Wasi` with member fields and appropriate APIs for dealing +// with all the various WASI exports. +wig::define_wasi_struct!( + "old/snapshot_0" "wasi_unstable" +); + +pub fn is_wasi_module(name: &str) -> bool { + // FIXME: this should be more conservative, but while WASI is in flux and + // we're figuring out how to support multiple revisions, this should do the + // trick. + name.starts_with("wasi") +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +
+//! Implementation of the WAST text format for wasmtime. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![deny(unstable_features)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default_derive) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod spectest; +mod wast; + +pub use crate::spectest::instantiate_spectest; +pub use crate::wast::WastContext; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +
+use std::collections::HashMap; +use wasmtime::*; + +/// Return an instance implementing the "spectest" interface used in the +/// spec testsuite. +pub fn instantiate_spectest(store: &Store) -> HashMap<&'static str, Extern> { + let mut ret = HashMap::new(); + + let func = Func::wrap0(store, || {}); + ret.insert("print", Extern::Func(func)); + + let func = Func::wrap1(store, |val: i32| println!("{}: i32", val)); + ret.insert("print_i32", Extern::Func(func)); + + let func = Func::wrap1(store, |val: i64| println!("{}: i64", val)); + ret.insert("print_i64", Extern::Func(func)); + + let func = Func::wrap1(store, |val: f32| println!("{}: f32", val)); + ret.insert("print_f32", Extern::Func(func)); + + let func = Func::wrap1(store, |val: f64| println!("{}: f64", val)); + ret.insert("print_f64", Extern::Func(func)); + + let func = Func::wrap2(store, |i: i32, f: f32| { + println!("{}: i32", i); + println!("{}: f32", f); + }); + ret.insert("print_i32_f32", Extern::Func(func)); + + let func = Func::wrap2(store, |f1: f64, f2: f64| { + println!("{}: f64", f1); + println!("{}: f64", f2); + }); + ret.insert("print_f64_f64", Extern::Func(func)); + + let ty = GlobalType::new(ValType::I32, Mutability::Const); + let g = Global::new(store, ty, Val::I32(666)).unwrap(); + ret.insert("global_i32", Extern::Global(g)); + + let ty = GlobalType::new(ValType::I64, Mutability::Const); + let g = Global::new(store, ty, Val::I64(666)).unwrap(); + ret.insert("global_i64", Extern::Global(g)); + + let ty = GlobalType::new(ValType::F32, Mutability::Const); + let g = Global::new(store, ty, Val::F32(0x4426_8000)).unwrap(); + ret.insert("global_f32", Extern::Global(g)); + + let ty = GlobalType::new(ValType::F64, Mutability::Const); + let g = Global::new(store, ty, Val::F64(0x4084_d000_0000_0000)).unwrap(); + ret.insert("global_f64", Extern::Global(g)); + + let ty = TableType::new(ValType::FuncRef, Limits::new(10, Some(20))); + let table = Table::new(store, ty, Val::AnyRef(AnyRef::Null)).unwrap(); + ret.insert("table", Extern::Table(table)); + + let ty = MemoryType::new(Limits::new(1, Some(2))); + let memory = Memory::new(store, ty); + ret.insert("memory", Extern::Memory(memory)); + + return ret; +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +
+use crate::spectest::instantiate_spectest; +use anyhow::{anyhow, bail, Context as _, Result}; +use std::collections::HashMap; +use std::path::Path; +use std::str; +use wasmtime::*; + +/// Translate from a `script::Value` to a `RuntimeValue`. +fn runtime_value(v: &wast::Expression<'_>) -> Result<Val> { + use wast::Instruction::*; + + if v.instrs.len() != 1 { + bail!("too many instructions in {:?}", v); + } + Ok(match &v.instrs[0] { + I32Const(x) => Val::I32(*x), + I64Const(x) => Val::I64(*x), + F32Const(x) => Val::F32(x.bits), + F64Const(x) => Val::F64(x.bits), + V128Const(x) => Val::V128(u128::from_le_bytes(x.to_le_bytes())), + other => bail!("couldn't convert {:?} to a runtime value", other), + }) +} + +/// The wast test script language allows modules to be defined and actions +/// to be performed on them. +pub struct WastContext { + /// Wast files have a concept of a "current" module, which is the most + /// recently defined. + current: Option<Instance>, + + instances: HashMap<String, Instance>, + store: Store, + spectest: Option<HashMap<&'static str, Extern>>, +} + +enum Outcome<T = Vec<Val>> { + Ok(T), + Trap(Trap), +} + +impl<T> Outcome<T> { + fn into_result(self) -> Result<T, Trap> { + match self { + Outcome::Ok(t) => Ok(t), + Outcome::Trap(t) => Err(t), + } + } +} + +impl WastContext { + /// Construct a new instance of `WastContext`. + pub fn new(store: Store) -> Self { + Self { + current: None, + store, + spectest: None, + instances: HashMap::new(), + } + } + + fn get_instance(&self, instance_name: Option<&str>) -> Result<Instance> { + match instance_name { + Some(name) => self + .instances + .get(name) + .cloned() + .ok_or_else(|| anyhow!("failed to find instance named `{}`", name)), + None => self + .current + .clone() + .ok_or_else(|| anyhow!("no previous instance found")), + } + } + + fn instantiate(&self, module: &[u8]) -> Result<Outcome<Instance>> { + let module = Module::new(&self.store, module)?; + let mut imports = Vec::new(); + for import in module.imports() { + if import.module() == "spectest" { + let spectest = self + .spectest + .as_ref() + .ok_or_else(|| anyhow!("spectest module isn't instantiated"))?; + let export = spectest + .get(import.name()) + .ok_or_else(|| anyhow!("unknown import `spectest::{}`", import.name()))?; + imports.push(export.clone()); + continue; + } + + let instance = self + .instances + .get(import.module()) + .ok_or_else(|| anyhow!("no module named `{}`", import.module()))?; + let export = instance + .get_export(import.name()) + .ok_or_else(|| anyhow!("unknown import `{}::{}`", import.name(), import.module()))? + .clone(); + imports.push(export); + } + let instance = match Instance::new(&module, &imports) { + Ok(i) => i, + Err(e) => return e.downcast::<Trap>().map(Outcome::Trap), + }; + Ok(Outcome::Ok(instance)) + } + + /// Register "spectest" which is used by the spec testsuite. + pub fn register_spectest(&mut self) -> Result<()> { + self.spectest = Some(instantiate_spectest(&self.store)); + Ok(()) + } + + /// Perform the action portion of a command. + fn perform_execute(&mut self, exec: wast::WastExecute<'_>) -> Result<Outcome> { + match exec { + wast::WastExecute::Invoke(invoke) => self.perform_invoke(invoke), + wast::WastExecute::Module(mut module) => { + let binary = module.encode()?; + let result = self.instantiate(&binary)?; + Ok(match result { + Outcome::Ok(_) => Outcome::Ok(Vec::new()), + Outcome::Trap(e) => Outcome::Trap(e), + }) + } + wast::WastExecute::Get { module, global } => self.get(module.map(|s| s.name()), global), + } + } + + fn perform_invoke(&mut self, exec: wast::WastInvoke<'_>) -> Result<Outcome> { + let values = exec + .args + .iter() + .map(runtime_value) + .collect::<Result<Vec<_>>>()?; + self.invoke(exec.module.map(|i| i.name()), exec.name, &values) + } + + /// Define a module and register it. + fn module(&mut self, instance_name: Option<&str>, module: &[u8]) -> Result<()> { + let instance = match self.instantiate(module)? { + Outcome::Ok(i) => i, + Outcome::Trap(e) => bail!("instantiation failed with: {}", e.message()), + }; + if let Some(name) = instance_name { + self.instances.insert(name.to_string(), instance.clone()); + } + self.current = Some(instance); + Ok(()) + } + + /// Register an instance to make it available for performing actions. + fn register(&mut self, name: Option<&str>, as_name: &str) -> Result<()> { + let instance = self.get_instance(name)?.clone(); + self.instances.insert(as_name.to_string(), instance); + Ok(()) + } + + /// Invoke an exported function from an instance. + fn invoke( + &mut self, + instance_name: Option<&str>, + field: &str, + args: &[Val], + ) -> Result<Outcome> { + let instance = self.get_instance(instance_name.as_ref().map(|x| &**x))?; + let func = instance + .get_export(field) + .and_then(|e| e.func()) + .ok_or_else(|| anyhow!("no function named `{}`", field))?; + Ok(match func.call(args) { + Ok(result) => Outcome::Ok(result.into()), + Err(e) => Outcome::Trap(e), + }) + } + + /// Get the value of an exported global from an instance. + fn get(&mut self, instance_name: Option<&str>, field: &str) -> Result<Outcome> { + let instance = self.get_instance(instance_name.as_ref().map(|x| &**x))?; + let global = instance + .get_export(field) + .and_then(|e| e.global()) + .ok_or_else(|| anyhow!("no global named `{}`", field))?; + Ok(Outcome::Ok(vec![global.get()])) + } + + fn assert_return(&self, result: Outcome, results: &[wast::AssertExpression]) -> Result<()> { + let values = result.into_result()?; + for (v, e) in values.iter().zip(results) { + if val_matches(v, e)? { + continue; + } + bail!("expected {:?}, got {:?}", e, v) + } + Ok(()) + } + + fn assert_trap(&self, result: Outcome, message: &str) -> Result<()> { + let trap = match result { + Outcome::Ok(values) => bail!("expected trap, got {:?}", values), + Outcome::Trap(t) => t, + }; + if trap.message().contains(message) { + return Ok(()); + } + if cfg!(feature = "lightbeam") { + println!("TODO: Check the assert_trap message: {}", message); + return Ok(()); + } + bail!("expected {}, got {}", message, trap.message()) + } + + /// Run a wast script from a byte buffer. + pub fn run_buffer(&mut self, filename: &str, wast: &[u8]) -> Result<()> { + let wast = str::from_utf8(wast)?; + + let adjust_wast = |mut err: wast::Error| { + err.set_path(filename.as_ref()); + err.set_text(wast); + err + }; + + let buf = wast::parser::ParseBuffer::new(wast).map_err(adjust_wast)?; + let ast = wast::parser::parse::<wast::Wast>(&buf).map_err(adjust_wast)?; + + for directive in ast.directives { + let sp = directive.span(); + self.run_directive(directive).with_context(|| { + let (line, col) = sp.linecol_in(wast); + format!("failed directive on {}:{}:{}", filename, line + 1, col) + })?; + } + Ok(()) + } + + fn run_directive(&mut self, directive: wast::WastDirective) -> Result<()> { + use wast::WastDirective::*; + + match directive { + Module(mut module) => { + let binary = module.encode()?; + self.module(module.name.map(|s| s.name()), &binary)?; + } + Register { + span: _, + name, + module, + } => { + self.register(module.map(|s| s.name()), name)?; + } + Invoke(i) => { + self.perform_invoke(i)?; + } + AssertReturn { + span: _, + exec, + results, + } => { + let result = self.perform_execute(exec)?; + self.assert_return(result, &results)?; + } + AssertTrap { + span: _, + exec, + message, + } => { + let result = self.perform_execute(exec)?; + self.assert_trap(result, message)?; + } + AssertExhaustion { + span: _, + call, + message, + } => { + let result = self.perform_invoke(call)?; + self.assert_trap(result, message)?; + } + AssertInvalid { + span: _, + mut module, + message, + } => { + let bytes = module.encode()?; + let err = match self.module(None, &bytes) { + Ok(()) => bail!("expected module to fail to build"), + Err(e) => e, + }; + let error_message = format!("{:?}", err); + if !error_message.contains(&message) { + bail!( + "assert_invalid: expected \"{}\", got \"{}\"", + message, + error_message + ) + } + } + AssertMalformed { + module, + span: _, + message: _, + } => { + let mut module = match module { + wast::QuoteModule::Module(m) => m, + // This is a `*.wat` parser test which we're not + // interested in. + wast::QuoteModule::Quote(_) => return Ok(()), + }; + let bytes = module.encode()?; + if let Ok(_) = self.module(None, &bytes) { + bail!("expected malformed module to fail to instantiate"); + } + } + AssertUnlinkable { + span: _, + mut module, + message, + } => { + let bytes = module.encode()?; + let err = match self.module(None, &bytes) { + Ok(()) => bail!("expected module to fail to link"), + Err(e) => e, + }; + let error_message = format!("{:?}", err); + if !error_message.contains(&message) { + bail!( + "assert_unlinkable: expected {}, got {}", + message, + error_message + ) + } + } + } + + Ok(()) + } + + /// Run a wast script from a file. + pub fn run_file(&mut self, path: &Path) -> Result<()> { + let bytes = + std::fs::read(path).with_context(|| format!("failed to read `{}`", path.display()))?; + self.run_buffer(path.to_str().unwrap(), &bytes) + } +} + +fn extract_lane_as_i8(bytes: u128, lane: usize) -> i8 { + (bytes >> (lane * 8)) as i8 +} + +fn extract_lane_as_i16(bytes: u128, lane: usize) -> i16 { + (bytes >> (lane * 16)) as i16 +} + +fn extract_lane_as_i32(bytes: u128, lane: usize) -> i32 { + (bytes >> (lane * 32)) as i32 +} + +fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 { + (bytes >> (lane * 64)) as i64 +} + +fn is_canonical_f32_nan(bits: u32) -> bool { + (bits & 0x7fff_ffff) == 0x7fc0_0000 +} + +fn is_canonical_f64_nan(bits: u64) -> bool { + (bits & 0x7fff_ffff_ffff_ffff) == 0x7ff8_0000_0000_0000 +} + +fn is_arithmetic_f32_nan(bits: u32) -> bool { + const AF32_NAN: u32 = 0x0040_0000; + (bits & AF32_NAN) == AF32_NAN +} + +fn is_arithmetic_f64_nan(bits: u64) -> bool { + const AF64_NAN: u64 = 0x0008_0000_0000_0000; + (bits & AF64_NAN) == AF64_NAN +} + +fn val_matches(actual: &Val, expected: &wast::AssertExpression) -> Result<bool> { + Ok(match (actual, expected) { + (Val::I32(a), wast::AssertExpression::I32(b)) => a == b, + (Val::I64(a), wast::AssertExpression::I64(b)) => a == b, + // Note that these float comparisons are comparing bits, not float + // values, so we're testing for bit-for-bit equivalence + (Val::F32(a), wast::AssertExpression::F32(b)) => f32_matches(*a, b), + (Val::F64(a), wast::AssertExpression::F64(b)) => f64_matches(*a, b), + (Val::V128(a), wast::AssertExpression::V128(b)) => v128_matches(*a, b), + _ => bail!( + "don't know how to compare {:?} and {:?} yet", + actual, + expected + ), + }) +} + +fn f32_matches(actual: u32, expected: &wast::NanPattern<wast::Float32>) -> bool { + match expected { + wast::NanPattern::CanonicalNan => is_canonical_f32_nan(actual), + wast::NanPattern::ArithmeticNan => is_arithmetic_f32_nan(actual), + wast::NanPattern::Value(expected_value) => actual == expected_value.bits, + } +} + +fn f64_matches(actual: u64, expected: &wast::NanPattern<wast::Float64>) -> bool { + match expected { + wast::NanPattern::CanonicalNan => is_canonical_f64_nan(actual), + wast::NanPattern::ArithmeticNan => is_arithmetic_f64_nan(actual), + wast::NanPattern::Value(expected_value) => actual == expected_value.bits, + } +} + +fn v128_matches(actual: u128, expected: &wast::V128Pattern) -> bool { + match expected { + wast::V128Pattern::I8x16(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i8(actual, i)), + wast::V128Pattern::I16x8(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i16(actual, i)), + wast::V128Pattern::I32x4(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i32(actual, i)), + wast::V128Pattern::I64x2(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i64(actual, i)), + wast::V128Pattern::F32x4(b) => b.iter().enumerate().all(|(i, b)| { + let a = extract_lane_as_i32(actual, i) as u32; + f32_matches(a, b) + }), + wast::V128Pattern::F64x2(b) => b.iter().enumerate().all(|(i, b)| { + let a = extract_lane_as_i64(actual, i) as u64; + f64_matches(a, b) + }), + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +
+use crate::utils; +use proc_macro2::TokenStream; +use quote::{format_ident, quote}; + +pub fn define(args: TokenStream) -> TokenStream { + let (path, phase) = utils::witx_path_from_args(args); + let doc = match witx::load(&[&path]) { + Ok(doc) => doc, + Err(e) => { + panic!("error opening file {}: {}", path, e); + } + }; + + let mut ret = TokenStream::new(); + + let old = match phase.as_str() { + "snapshot" => false, + "old/snapshot_0" => true, + s => panic!("unsupported phase: {}", s), + }; + + for module in doc.modules() { + for func in module.funcs() { + ret.extend(generate_wrappers(&func, old)); + } + } + + return ret; +} + +fn generate_wrappers(func: &witx::InterfaceFunc, old: bool) -> TokenStream { + let name = format_ident!("{}", func.name.as_str()); + let mut arg_declarations = Vec::new(); + let mut arg_names = Vec::new(); + + for param in func.params.iter() { + let name = utils::param_name(param); + + if let witx::TypePassedBy::PointerLengthPair = param.tref.type_().passed_by() { + let ptr = format_ident!("{}_ptr", name); + let len = format_ident!("{}_len", name); + arg_declarations.push(quote! { #ptr: super::wasi32::uintptr_t }); + arg_declarations.push(quote! { #len: super::wasi32::size_t }); + arg_names.push(ptr); + arg_names.push(len); + continue; + } + + match ¶m.tref { + witx::TypeRef::Name(n) => { + if n.name.as_str() == "size" { + arg_declarations.push(quote! { #name: super::wasi32::size_t }); + } else { + let ty_name = format_ident!("__wasi_{}_t", n.name.as_str()); + arg_declarations.push(quote! { #name: super::wasi::#ty_name }); + } + } + witx::TypeRef::Value(v) => match &**v { + witx::Type::ConstPointer(_) | witx::Type::Pointer(_) => { + arg_declarations.push(quote! { #name: super::wasi32::uintptr_t }); + } + _ => panic!("unexpected value type"), + }, + } + arg_names.push(name); + } + + let mut ret = quote!(()); + + for (i, result) in func.results.iter().enumerate() { + if i == 0 { + match &result.tref { + witx::TypeRef::Name(n) => { + let ty_name = format_ident!("__wasi_{}_t", n.name.as_str()); + ret = quote! { super::wasi::#ty_name }; + } + witx::TypeRef::Value(_) => panic!("unexpected value type"), + } + continue; + } + let name = utils::param_name(result); + arg_declarations.push(quote! { #name: super::wasi32::uintptr_t }); + arg_names.push(name); + } + + let call = quote! { + super::hostcalls_impl::#name(wasi_ctx, memory, #(#arg_names,)*) + }; + let body = if func.results.len() == 0 { + call + } else { + quote! { + let ret = #call + .err() + .unwrap_or(super::Error::ESUCCESS) + .as_wasi_error(); + log::trace!(" | errno={}", ret); + ret.as_raw_errno() + } + }; + + let c_abi_name = if old { + format_ident!("old_wasi_common_{}", name) + } else { + format_ident!("wasi_common_{}", name) + }; + + quote! { + pub unsafe fn #name( + wasi_ctx: &mut super::WasiCtx, + memory: &mut [u8], + #(#arg_declarations,)* + ) -> #ret { + #body + } + + #[no_mangle] + pub unsafe fn #c_abi_name( + wasi_ctx: *mut super::WasiCtx, + memory: *mut u8, + memory_len: usize, + #(#arg_declarations,)* + ) -> #ret { + #name( + &mut *wasi_ctx, + std::slice::from_raw_parts_mut(memory, memory_len), + #(#arg_names,)* + ) + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +
+extern crate proc_macro; + +mod hostcalls; +mod raw_types; +mod utils; +mod wasi; + +use proc_macro::TokenStream; +use proc_macro2::TokenStream as TokenStream2; + +#[proc_macro] +pub fn witx_host_types(args: TokenStream) -> TokenStream { + TokenStream::from(raw_types::gen( + TokenStream2::from(args), + raw_types::Mode::Host, + )) +} + +#[proc_macro] +pub fn witx_wasi_types(args: TokenStream) -> TokenStream { + TokenStream::from(raw_types::gen( + TokenStream2::from(args), + raw_types::Mode::Wasi, + )) +} + +#[proc_macro] +pub fn witx_wasi32_types(args: TokenStream) -> TokenStream { + TokenStream::from(raw_types::gen( + TokenStream2::from(args), + raw_types::Mode::Wasi32, + )) +} + +/// A single-use macro in the `wasmtime-wasi` crate. +#[proc_macro] +pub fn define_wasi_struct(args: TokenStream) -> TokenStream { + wasi::define_struct(args.into()).into() +} + +#[proc_macro] +pub fn define_hostcalls(args: TokenStream) -> TokenStream { + hostcalls::define(args.into()).into() +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +
+//! Translate witx types to Rust. + +use crate::utils; +use heck::ShoutySnakeCase; +use proc_macro2::{Delimiter, Group, Literal, TokenStream, TokenTree}; +use quote::{format_ident, quote}; +use std::convert::TryFrom; + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum Mode { + Host, + Wasi32, + Wasi, +} + +impl Mode { + pub fn include_target_types(&self) -> bool { + match self { + Mode::Host | Mode::Wasi32 => true, + Mode::Wasi => false, + } + } +} + +pub fn gen(args: TokenStream, mode: Mode) -> TokenStream { + let mut output = TokenStream::new(); + + let (path, _phase) = utils::witx_path_from_args(args); + let doc = match witx::load(&[&path]) { + Ok(doc) => doc, + Err(e) => { + panic!("error opening file {}: {}", path, e); + } + }; + + gen_datatypes(&mut output, &doc, mode); + + output +} + +fn gen_datatypes(output: &mut TokenStream, doc: &witx::Document, mode: Mode) { + for namedtype in doc.typenames() { + if mode.include_target_types() != namedtype_has_target_size(&namedtype) { + continue; + } + + gen_datatype(output, mode, &namedtype); + } +} + +fn gen_datatype(output: &mut TokenStream, mode: Mode, namedtype: &witx::NamedType) { + let wasi_name = format_ident!("__wasi_{}_t", namedtype.name.as_str()); + match &namedtype.tref { + witx::TypeRef::Name(alias_to) => { + let to = tref_tokens(mode, &alias_to.tref); + output.extend(quote!(pub type #wasi_name = #to;)); + } + witx::TypeRef::Value(v) => match &**v { + witx::Type::Int(_) => panic!("unsupported int datatype"), + witx::Type::Enum(e) => { + let repr = int_repr_tokens(e.repr); + output.extend(quote!(pub type #wasi_name = #repr;)); + for (index, variant) in e.variants.iter().enumerate() { + let value_name = format_ident!( + "__WASI_{}_{}", + namedtype.name.as_str().to_shouty_snake_case(), + variant.name.as_str().to_shouty_snake_case() + ); + let index_name = Literal::usize_unsuffixed(index); + output.extend(quote!(pub const #value_name: #wasi_name = #index_name;)); + } + } + witx::Type::Flags(f) => { + let repr = int_repr_tokens(f.repr); + output.extend(quote!(pub type #wasi_name = #repr;)); + for (index, flag) in f.flags.iter().enumerate() { + let value_name = format_ident!( + "__WASI_{}_{}", + namedtype.name.as_str().to_shouty_snake_case(), + flag.name.as_str().to_shouty_snake_case() + ); + let flag_value = Literal::u128_unsuffixed( + 1u128 + .checked_shl(u32::try_from(index).expect("flag value overflow")) + .expect("flag value overflow"), + ); + output.extend(quote!(pub const #value_name: #wasi_name = #flag_value;)); + } + } + witx::Type::Struct(s) => { + output.extend(quote!(#[repr(C)])); + // Types which contain unions can't trivially implement Debug, + // Hash, or Eq, because the type itself doesn't record which + // union member is active. + if struct_has_union(&s) { + output.extend(quote!(#[derive(Copy, Clone)])); + output.extend(quote!(#[allow(missing_debug_implementations)])); + } else { + output.extend(quote!(#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)])); + } + + output.extend(quote!(pub struct #wasi_name)); + + let mut inner = TokenStream::new(); + for member in &s.members { + let member_name = format_ident!("r#{}", member.name.as_str()); + let member_type = tref_tokens(mode, &member.tref); + inner.extend(quote!(pub #member_name: #member_type,)); + } + let braced = Group::new(Delimiter::Brace, inner); + output.extend(TokenStream::from(TokenTree::Group(braced))); + } + witx::Type::Union(u) => { + output.extend(quote!(#[repr(C)])); + output.extend(quote!(#[derive(Copy, Clone)])); + output.extend(quote!(#[allow(missing_debug_implementations)])); + + output.extend(quote!(pub union #wasi_name)); + + let mut inner = TokenStream::new(); + for variant in &u.variants { + let variant_name = format_ident!("r#{}", variant.name.as_str()); + let variant_type = tref_tokens(mode, &variant.tref); + inner.extend(quote!(pub #variant_name: #variant_type,)); + } + let braced = Group::new(Delimiter::Brace, inner); + output.extend(TokenStream::from(TokenTree::Group(braced))); + } + witx::Type::Handle(_h) => { + output.extend(quote!(pub type #wasi_name = u32;)); + } + witx::Type::Builtin(b) => { + if namedtype.name.as_str() == "size" { + match mode { + Mode::Host => output.extend(quote!(pub type #wasi_name = usize;)), + Mode::Wasi => panic!("size has target-specific size"), + Mode::Wasi32 => output.extend(quote!(pub type #wasi_name = u32;)), + } + } else { + let b_type = builtin_tokens(mode, *b); + output.extend(quote!(pub type #wasi_name = #b_type;)); + } + } + witx::Type::Pointer { .. } + | witx::Type::ConstPointer { .. } + | witx::Type::Array { .. } => { + let tref_tokens = tref_tokens(mode, &namedtype.tref); + output.extend(quote!(pub type #wasi_name = #tref_tokens;)); + } + }, + } + + if namedtype.name.as_str() == "errno" { + // Generate strerror for errno type + gen_errno_strerror(output, namedtype); + } +} + +fn gen_errno_strerror(output: &mut TokenStream, namedtype: &witx::NamedType) { + let inner = match &namedtype.tref { + witx::TypeRef::Value(v) => match &**v { + witx::Type::Enum(e) => e, + x => panic!("expected Enum('errno'), instead received {:?}", x), + }, + x => panic!("expected Enum('errno'), instead received {:?}", x), + }; + let mut inner_group = TokenStream::new(); + for variant in &inner.variants { + let value_name = format_ident!( + "__WASI_ERRNO_{}", + variant.name.as_str().to_shouty_snake_case() + ); + let docs = variant.docs.trim(); + inner_group.extend(quote!(#value_name => #docs,)); + } + output.extend( + quote!(pub fn strerror(errno: __wasi_errno_t) -> &'static str { + match errno { + #inner_group + other => panic!("Undefined errno value {:?}", other), + } + }), + ); +} + +fn int_repr_tokens(int_repr: witx::IntRepr) -> TokenStream { + match int_repr { + witx::IntRepr::U8 => quote!(u8), + witx::IntRepr::U16 => quote!(u16), + witx::IntRepr::U32 => quote!(u32), + witx::IntRepr::U64 => quote!(u64), + } +} + +fn builtin_tokens(mode: Mode, builtin: witx::BuiltinType) -> TokenStream { + match builtin { + witx::BuiltinType::String => match mode { + Mode::Host => quote!((*const u8, usize)), + Mode::Wasi => panic!("strings have target-specific size"), + Mode::Wasi32 => quote!((u32, u32)), + }, + witx::BuiltinType::Char8 => quote!(i8), + witx::BuiltinType::U8 => quote!(u8), + witx::BuiltinType::U16 => quote!(u16), + witx::BuiltinType::U32 => quote!(u32), + witx::BuiltinType::U64 => quote!(u64), + witx::BuiltinType::S8 => quote!(i8), + witx::BuiltinType::S16 => quote!(i16), + witx::BuiltinType::S32 => quote!(i32), + witx::BuiltinType::S64 => quote!(i64), + witx::BuiltinType::F32 => quote!(f32), + witx::BuiltinType::F64 => quote!(f64), + witx::BuiltinType::USize => match mode { + Mode::Host => quote!(usize), + Mode::Wasi => panic!("usize has target-specific size"), + Mode::Wasi32 => quote!(u32), + }, + } +} + +fn tref_tokens(mode: Mode, tref: &witx::TypeRef) -> TokenStream { + match tref { + witx::TypeRef::Name(n) => TokenStream::from(TokenTree::Ident(format_ident!( + "__wasi_{}_t", + n.name.as_str() + ))), + witx::TypeRef::Value(v) => match &**v { + witx::Type::Builtin(b) => builtin_tokens(mode, *b), + witx::Type::Pointer(pointee) => { + let pointee = tref_tokens(mode, pointee); + match mode { + Mode::Host => quote!(*mut #pointee), + Mode::Wasi => panic!("pointers have target-specific size"), + Mode::Wasi32 => quote!(u32), + } + } + witx::Type::ConstPointer(pointee) => { + let pointee = tref_tokens(mode, pointee); + match mode { + Mode::Host => quote!(*const #pointee), + Mode::Wasi => panic!("pointers have target-specific size"), + Mode::Wasi32 => quote!(u32), + } + } + witx::Type::Array(element) => { + let element_name = tref_tokens(mode, element); + match mode { + Mode::Host => quote!((*const #element_name, usize)), + Mode::Wasi => panic!("arrays have target-specific size"), + Mode::Wasi32 => quote!((u32, u32)), + } + } + t => panic!("cannot give name to anonymous type {:?}", t), + }, + } +} + +/// Test whether the given struct contains any union members. +fn struct_has_union(s: &witx::StructDatatype) -> bool { + s.members.iter().any(|member| match &*member.tref.type_() { + witx::Type::Union { .. } => true, + witx::Type::Struct(s) => struct_has_union(&s), + _ => false, + }) +} + +/// Test whether the type referred to has a target-specific size. +fn tref_has_target_size(tref: &witx::TypeRef) -> bool { + match tref { + witx::TypeRef::Name(nt) => namedtype_has_target_size(&nt), + witx::TypeRef::Value(t) => type_has_target_size(&t), + } +} + +/// Test whether the given named type has a target-specific size. +fn namedtype_has_target_size(nt: &witx::NamedType) -> bool { + if nt.name.as_str() == "size" { + true + } else { + tref_has_target_size(&nt.tref) + } +} + +/// Test whether the given type has a target-specific size. +fn type_has_target_size(ty: &witx::Type) -> bool { + match ty { + witx::Type::Builtin(witx::BuiltinType::String) => true, + witx::Type::Pointer { .. } | witx::Type::ConstPointer { .. } => true, + witx::Type::Array(elem) => tref_has_target_size(elem), + witx::Type::Struct(s) => s.members.iter().any(|m| tref_has_target_size(&m.tref)), + witx::Type::Union(u) => u.variants.iter().any(|v| tref_has_target_size(&v.tref)), + _ => false, + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +
+use proc_macro2::{Ident, Literal, TokenStream, TokenTree}; + +/// Given the input tokens to a macro invocation, return the path to the +/// witx file to process. +pub(crate) fn witx_path_from_args(args: TokenStream) -> (String, String) { + let mut strings = Vec::new(); + + for arg in args { + if let TokenTree::Literal(literal) = arg { + let parsed = parse_string_literal(literal); + + strings.push(parsed); + } else { + panic!("arguments must be string literals"); + } + } + + if strings.len() != 2 { + panic!("expected two string literals"); + } + + let phase = &strings[0]; + let id = &strings[1]; + let path = witx_path(phase, id); + + (path, phase.clone()) +} + +fn witx_path(phase: &str, id: &str) -> String { + let root = env!("CARGO_MANIFEST_DIR"); + format!("{}/WASI/phases/{}/witx/{}.witx", root, phase, id) +} + +// Convert a `Literal` holding a string literal into the `String`. +// +// FIXME: It feels like there should be an easier way to do this. +fn parse_string_literal(literal: Literal) -> String { + let s = literal.to_string(); + assert!( + s.starts_with('"') && s.ends_with('"'), + "string literal must be enclosed in double-quotes" + ); + + let trimmed = s[1..s.len() - 1].to_owned(); + assert!( + !trimmed.contains('"'), + "string literal must not contain embedded quotes for now" + ); + assert!( + !trimmed.contains('\\'), + "string literal must not contain embedded backslashes for now" + ); + + trimmed +} + +pub fn param_name(param: &witx::InterfaceFuncParam) -> Ident { + quote::format_ident!( + "{}", + match param.name.as_str() { + "in" | "type" => format!("r#{}", param.name.as_str()), + s => s.to_string(), + } + ) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +
+use crate::utils; +use proc_macro2::{Ident, Span, TokenStream}; +use quote::{format_ident, quote}; + +enum Abi { + I32, + I64, + F32, + F64, +} + +/// This is a single-use macro intended to be used in the `wasmtime-wasi` crate. +/// +/// This macro will generate a structure, `Wasi`, which will create all the +/// functions necessary to bind wasi and hook everything up via the `wasmtime` +/// crate. +/// +/// The generated shim functions here will also `trace!` their arguments for +/// logging purposes. Otherwise this is hopefully somewhat straightforward! +/// +/// I'd recommend using `cargo +nightly expand` to explore the output of this +/// macro some more. +pub fn define_struct(args: TokenStream) -> TokenStream { + let (path, _phase) = utils::witx_path_from_args(args); + let doc = match witx::load(&[&path]) { + Ok(doc) => doc, + Err(e) => { + panic!("error opening file {}: {}", path, e); + } + }; + + let mut fields = Vec::new(); + let mut get_exports = Vec::new(); + let mut ctor_externs = Vec::new(); + let mut ctor_fields = Vec::new(); + + for module in doc.modules() { + for func in module.funcs() { + let name = func.name.as_str(); + let name_ident = Ident::new(func.name.as_str(), Span::call_site()); + fields.push(quote! { pub #name_ident: wasmtime::Func }); + get_exports.push(quote! { #name => Some(&self.#name_ident) }); + ctor_fields.push(name_ident.clone()); + + let mut shim_arg_decls = Vec::new(); + let mut params = Vec::new(); + let mut formats = Vec::new(); + let mut format_args = Vec::new(); + let mut hostcall_args = Vec::new(); + + for param in func.params.iter() { + let name = utils::param_name(param); + + // Registers a new parameter to the shim we're making with the + // given `name`, the `abi_ty` wasm type and `hex` defines + // whether it's debug-printed in a hex format or not. + // + // This will register a whole bunch of things: + // + // * The cranelift type for the parameter + // * Syntax to specify the actual function parameter + // * How to log the parameter value in a call to `trace!` + // * How to actually pass this argument to the host + // implementation, converting as necessary. + let mut add_param = |name: &Ident, abi_ty: Abi, hex: bool| { + match abi_ty { + Abi::I32 => { + params.push(quote! { types::I32 }); + shim_arg_decls.push(quote! { #name: i32 }); + } + Abi::I64 => { + params.push(quote! { types::I64 }); + shim_arg_decls.push(quote! { #name: i64 }); + } + Abi::F32 => { + params.push(quote! { types::F32 }); + shim_arg_decls.push(quote! { #name: f32 }); + } + Abi::F64 => { + params.push(quote! { types::F64 }); + shim_arg_decls.push(quote! { #name: f64 }); + } + } + formats.push(format!("{}={}", name, if hex { "{:#x}" } else { "{}" },)); + format_args.push(name.clone()); + hostcall_args.push(quote! { #name as _ }); + }; + + match &*param.tref.type_() { + witx::Type::Int(e) => match e.repr { + witx::IntRepr::U64 => add_param(&name, Abi::I64, false), + _ => add_param(&name, Abi::I32, false), + }, + + witx::Type::Enum(e) => match e.repr { + witx::IntRepr::U64 => add_param(&name, Abi::I64, false), + _ => add_param(&name, Abi::I32, false), + }, + + witx::Type::Flags(f) => match f.repr { + witx::IntRepr::U64 => add_param(&name, Abi::I64, true), + _ => add_param(&name, Abi::I32, true), + }, + + witx::Type::Builtin(witx::BuiltinType::Char8) + | witx::Type::Builtin(witx::BuiltinType::S8) + | witx::Type::Builtin(witx::BuiltinType::U8) + | witx::Type::Builtin(witx::BuiltinType::S16) + | witx::Type::Builtin(witx::BuiltinType::U16) + | witx::Type::Builtin(witx::BuiltinType::S32) + | witx::Type::Builtin(witx::BuiltinType::U32) + | witx::Type::Builtin(witx::BuiltinType::USize) => { + add_param(&name, Abi::I32, false); + } + + witx::Type::Builtin(witx::BuiltinType::S64) + | witx::Type::Builtin(witx::BuiltinType::U64) => { + add_param(&name, Abi::I64, false); + } + + witx::Type::Builtin(witx::BuiltinType::F32) => { + add_param(&name, Abi::F32, false); + } + + witx::Type::Builtin(witx::BuiltinType::F64) => { + add_param(&name, Abi::F64, false); + } + + // strings/arrays have an extra ABI parameter for the length + // of the array passed. + witx::Type::Builtin(witx::BuiltinType::String) | witx::Type::Array(_) => { + add_param(&name, Abi::I32, true); + let len = format_ident!("{}_len", name); + add_param(&len, Abi::I32, false); + } + + witx::Type::ConstPointer(_) + | witx::Type::Handle(_) + | witx::Type::Pointer(_) => { + add_param(&name, Abi::I32, true); + } + + witx::Type::Struct(_) | witx::Type::Union(_) => { + panic!("unsupported argument type") + } + } + } + + let mut results = func.results.iter(); + let mut ret_ty = quote! { () }; + let mut cvt_ret = quote! {}; + let mut returns = Vec::new(); + let mut handle_early_error = quote! { panic!("error: {:?}", e) }; + + // The first result is returned bare right now... + if let Some(ret) = results.next() { + handle_early_error = quote! { return e.into() }; + match &*ret.tref.type_() { + // Eventually we'll want to add support for more returned + // types, but for now let's just conform to what `*.witx` + // definitions currently use. + witx::Type::Enum(e) => match e.repr { + witx::IntRepr::U16 => { + returns.push(quote! { types::I32 }); + ret_ty = quote! { i32 }; + cvt_ret = quote! { .into() } + } + other => panic!("unsupported ret enum repr {:?}", other), + }, + other => panic!("unsupported first return {:?}", other), + } + } + + // ... and all remaining results are returned via out-poiners + for result in results { + let name = format_ident!("{}", result.name.as_str()); + params.push(quote! { types::I32 }); + shim_arg_decls.push(quote! { #name: i32 }); + formats.push(format!("{}={{:#x}}", name)); + format_args.push(name.clone()); + hostcall_args.push(quote! { #name as u32 }); + } + + let format_str = format!("{}({})", name, formats.join(", ")); + let wrap = format_ident!("wrap{}", shim_arg_decls.len() + 1); + ctor_externs.push(quote! { + let my_cx = cx.clone(); + let #name_ident = wasmtime::Func::#wrap( + store, + move |mem: crate::WasiCallerMemory #(,#shim_arg_decls)*| -> #ret_ty { + log::trace!( + #format_str, + #(#format_args),* + ); + unsafe { + let memory = match mem.get() { + Ok(e) => e, + Err(e) => #handle_early_error, + }; + hostcalls::#name_ident( + &mut my_cx.borrow_mut(), + memory, + #(#hostcall_args),* + ) #cvt_ret + } + } + ); + }); + } + } + + quote! { + /// An instantiated instance of the wasi exports. + /// + /// This represents a wasi module which can be used to instantiate other + /// wasm modules. This structure exports all that various fields of the + /// wasi instance as fields which can be used to implement your own + /// instantiation logic, if necessary. Additionally [`Wasi::get_export`] + /// can be used to do name-based resolution. + pub struct Wasi { + #(#fields,)* + } + + impl Wasi { + /// Creates a new [`Wasi`] instance. + /// + /// External values are allocated into the `store` provided and + /// configuration of the wasi instance itself should be all + /// contained in the `cx` parameter. + pub fn new(store: &wasmtime::Store, cx: WasiCtx) -> Wasi { + let cx = std::rc::Rc::new(std::cell::RefCell::new(cx)); + #(#ctor_externs)* + + Wasi { + #(#ctor_fields,)* + } + } + + /// Looks up a field called `name` in this structure, returning it + /// if found. + /// + /// This is often useful when instantiating a `wasmtime` instance + /// where name resolution often happens with strings. + pub fn get_export(&self, name: &str) -> Option<&wasmtime::Func> { + match name { + #(#get_exports,)* + _ => None, + } + } + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +
+#![deny( + // missing_docs, + trivial_numeric_casts, + unused_extern_crates, + unstable_features +)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../clippy.toml")))] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] +#![cfg(windows)] + +pub mod file; +mod ntdll; +pub mod time; +pub mod winerror; + +use winerror::WinError; + +pub type Result<T> = std::result::Result<T, WinError>; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +
+use crate::{Errno, Result}; +use std::mem::MaybeUninit; + +#[derive(Debug, Copy, Clone)] +pub enum ClockId { + Realtime, + Monotonic, + ProcessCPUTime, + ThreadCPUTime, +} + +impl ClockId { + pub fn as_raw(&self) -> libc::clockid_t { + match self { + Self::Realtime => libc::CLOCK_REALTIME, + Self::Monotonic => libc::CLOCK_MONOTONIC, + Self::ProcessCPUTime => libc::CLOCK_PROCESS_CPUTIME_ID, + Self::ThreadCPUTime => libc::CLOCK_THREAD_CPUTIME_ID, + } + } +} + +pub fn clock_getres(clock_id: ClockId) -> Result<libc::timespec> { + let mut timespec = MaybeUninit::<libc::timespec>::uninit(); + Errno::from_success_code(unsafe { + libc::clock_getres(clock_id.as_raw(), timespec.as_mut_ptr()) + })?; + Ok(unsafe { timespec.assume_init() }) +} + +pub fn clock_gettime(clock_id: ClockId) -> Result<libc::timespec> { + let mut timespec = MaybeUninit::<libc::timespec>::uninit(); + Errno::from_success_code(unsafe { + libc::clock_gettime(clock_id.as_raw(), timespec.as_mut_ptr()) + })?; + Ok(unsafe { timespec.assume_init() }) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +
+use crate::{ + sys::dir::{iter_impl, EntryImpl}, + Errno, Result, +}; +use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; +use std::{ffi::CStr, ops::Deref, ptr}; + +pub use crate::sys::EntryExt; + +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub struct Dir(ptr::NonNull<libc::DIR>); + +impl Dir { + /// Takes the ownership of the passed-in descriptor-based object, + /// and creates a new instance of `Dir`. + #[inline] + pub fn from<F: IntoRawFd>(fd: F) -> Result<Self> { + let fd = fd.into_raw_fd(); + unsafe { Self::from_fd(fd) } + } + + unsafe fn from_fd(fd: RawFd) -> Result<Self> { + let d = libc::fdopendir(fd); + if let Some(d) = ptr::NonNull::new(d) { + Ok(Self(d)) + } else { + let e = Errno::last(); + libc::close(fd); + Err(e.into()) + } + } + + /// Set the position of the directory stream, see `seekdir(3)`. + #[cfg(not(target_os = "android"))] + pub fn seek(&mut self, loc: SeekLoc) { + unsafe { libc::seekdir(self.0.as_ptr(), loc.0) } + } + + /// Reset directory stream, see `rewinddir(3)`. + pub fn rewind(&mut self) { + unsafe { libc::rewinddir(self.0.as_ptr()) } + } + + /// Get the current position in the directory stream. + /// + /// If this location is given to `Dir::seek`, the entries up to the previously returned + /// will be omitted and the iteration will start from the currently pending directory entry. + #[cfg(not(target_os = "android"))] + #[allow(dead_code)] + pub fn tell(&self) -> SeekLoc { + let loc = unsafe { libc::telldir(self.0.as_ptr()) }; + SeekLoc(loc) + } + + /// For use by platform-specific implementation code. Returns the raw + /// underlying state. + pub(crate) fn as_raw(&self) -> ptr::NonNull<libc::DIR> { + self.0 + } +} + +unsafe impl Send for Dir {} + +impl AsRawFd for Dir { + fn as_raw_fd(&self) -> RawFd { + unsafe { libc::dirfd(self.0.as_ptr()) } + } +} + +impl Drop for Dir { + fn drop(&mut self) { + unsafe { libc::closedir(self.0.as_ptr()) }; + } +} + +#[derive(Debug, Copy, Clone)] +pub struct Entry(pub(crate) EntryImpl); + +impl Entry { + /// Returns the file name of this directory entry. + pub fn file_name(&self) -> &CStr { + unsafe { CStr::from_ptr(self.0.d_name.as_ptr()) } + } + + /// Returns the type of this directory entry. + pub fn file_type(&self) -> FileType { + FileType::from_raw(self.0.d_type) + } +} + +#[cfg(not(target_os = "android"))] +#[derive(Clone, Copy, Debug)] +pub struct SeekLoc(pub(crate) libc::c_long); + +#[cfg(not(target_os = "android"))] +impl SeekLoc { + pub fn to_raw(&self) -> i64 { + self.0.into() + } +} + +#[derive(Clone, Copy, Debug)] +#[repr(u8)] +pub enum FileType { + CharacterDevice = libc::DT_CHR, + Directory = libc::DT_DIR, + BlockDevice = libc::DT_BLK, + RegularFile = libc::DT_REG, + Symlink = libc::DT_LNK, + Fifo = libc::DT_FIFO, + Socket = libc::DT_SOCK, + Unknown = libc::DT_UNKNOWN, +} + +impl FileType { + pub fn from_raw(file_type: u8) -> Self { + match file_type { + libc::DT_CHR => Self::CharacterDevice, + libc::DT_DIR => Self::Directory, + libc::DT_BLK => Self::BlockDevice, + libc::DT_REG => Self::RegularFile, + libc::DT_LNK => Self::Symlink, + libc::DT_SOCK => Self::Socket, + libc::DT_FIFO => Self::Fifo, + /* libc::DT_UNKNOWN */ _ => Self::Unknown, + } + } + + pub fn to_raw(&self) -> u8 { + match self { + Self::CharacterDevice => libc::DT_CHR, + Self::Directory => libc::DT_DIR, + Self::BlockDevice => libc::DT_BLK, + Self::RegularFile => libc::DT_REG, + Self::Symlink => libc::DT_LNK, + Self::Socket => libc::DT_SOCK, + Self::Fifo => libc::DT_FIFO, + Self::Unknown => libc::DT_UNKNOWN, + } + } +} + +#[derive(Debug)] +pub struct DirIter<T: Deref<Target = Dir>>(T); + +impl<T> DirIter<T> +where + T: Deref<Target = Dir>, +{ + pub fn new(dir: T) -> Self { + Self(dir) + } +} + +impl<T> Iterator for DirIter<T> +where + T: Deref<Target = Dir>, +{ + type Item = Result<Entry>; + + fn next(&mut self) -> Option<Self::Item> { + iter_impl(&self.0).map(|x| x.map(Entry)) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +
+//! Errno-specific for different Unix platforms +use crate::Result; +use std::{fmt, io}; +use thiserror::Error; + +#[derive(Debug, Copy, Clone, Error, PartialEq, Eq, Hash)] +#[repr(i32)] +pub enum Errno { + EPERM = libc::EPERM, + ENOENT = libc::ENOENT, + ESRCH = libc::ESRCH, + EINTR = libc::EINTR, + EIO = libc::EIO, + ENXIO = libc::ENXIO, + E2BIG = libc::E2BIG, + ENOEXEC = libc::ENOEXEC, + EBADF = libc::EBADF, + ECHILD = libc::ECHILD, + EAGAIN = libc::EAGAIN, + ENOMEM = libc::ENOMEM, + EACCES = libc::EACCES, + EFAULT = libc::EFAULT, + EBUSY = libc::EBUSY, + EEXIST = libc::EEXIST, + EXDEV = libc::EXDEV, + ENODEV = libc::ENODEV, + ENOTDIR = libc::ENOTDIR, + EISDIR = libc::EISDIR, + EINVAL = libc::EINVAL, + ENFILE = libc::ENFILE, + EMFILE = libc::EMFILE, + ENOTTY = libc::ENOTTY, + ETXTBSY = libc::ETXTBSY, + EFBIG = libc::EFBIG, + ENOSPC = libc::ENOSPC, + ESPIPE = libc::ESPIPE, + EROFS = libc::EROFS, + EMLINK = libc::EMLINK, + EPIPE = libc::EPIPE, + EDOM = libc::EDOM, + ERANGE = libc::ERANGE, + EDEADLK = libc::EDEADLK, + ENAMETOOLONG = libc::ENAMETOOLONG, + ENOLCK = libc::ENOLCK, + ENOSYS = libc::ENOSYS, + ENOTEMPTY = libc::ENOTEMPTY, + ELOOP = libc::ELOOP, + ENOMSG = libc::ENOMSG, + EIDRM = libc::EIDRM, + ENOLINK = libc::ENOLINK, + EPROTO = libc::EPROTO, + EMULTIHOP = libc::EMULTIHOP, + EBADMSG = libc::EBADMSG, + EOVERFLOW = libc::EOVERFLOW, + EILSEQ = libc::EILSEQ, + ENOTSOCK = libc::ENOTSOCK, + EDESTADDRREQ = libc::EDESTADDRREQ, + EMSGSIZE = libc::EMSGSIZE, + EPROTOTYPE = libc::EPROTOTYPE, + ENOPROTOOPT = libc::ENOPROTOOPT, + EPROTONOSUPPORT = libc::EPROTONOSUPPORT, + EAFNOSUPPORT = libc::EAFNOSUPPORT, + EADDRINUSE = libc::EADDRINUSE, + EADDRNOTAVAIL = libc::EADDRNOTAVAIL, + ENETDOWN = libc::ENETDOWN, + ENETUNREACH = libc::ENETUNREACH, + ENETRESET = libc::ENETRESET, + ECONNABORTED = libc::ECONNABORTED, + ECONNRESET = libc::ECONNRESET, + ENOBUFS = libc::ENOBUFS, + EISCONN = libc::EISCONN, + ENOTCONN = libc::ENOTCONN, + ETIMEDOUT = libc::ETIMEDOUT, + ECONNREFUSED = libc::ECONNREFUSED, + EHOSTUNREACH = libc::EHOSTUNREACH, + EALREADY = libc::EALREADY, + EINPROGRESS = libc::EINPROGRESS, + ESTALE = libc::ESTALE, + EDQUOT = libc::EDQUOT, + ECANCELED = libc::ECANCELED, + EOWNERDEAD = libc::EOWNERDEAD, + ENOTRECOVERABLE = libc::ENOTRECOVERABLE, +} + +impl Errno { + pub fn from_i32(err: i32) -> Self { + match err { + libc::EPERM => Self::EPERM, + libc::ENOENT => Self::ENOENT, + libc::ESRCH => Self::ESRCH, + libc::EINTR => Self::EINTR, + libc::EIO => Self::EIO, + libc::ENXIO => Self::ENXIO, + libc::E2BIG => Self::E2BIG, + libc::ENOEXEC => Self::ENOEXEC, + libc::EBADF => Self::EBADF, + libc::ECHILD => Self::ECHILD, + libc::EAGAIN => Self::EAGAIN, + libc::ENOMEM => Self::ENOMEM, + libc::EACCES => Self::EACCES, + libc::EFAULT => Self::EFAULT, + libc::EBUSY => Self::EBUSY, + libc::EEXIST => Self::EEXIST, + libc::EXDEV => Self::EXDEV, + libc::ENODEV => Self::ENODEV, + libc::ENOTDIR => Self::ENOTDIR, + libc::EISDIR => Self::EISDIR, + libc::EINVAL => Self::EINVAL, + libc::ENFILE => Self::ENFILE, + libc::EMFILE => Self::EMFILE, + libc::ENOTTY => Self::ENOTTY, + libc::ETXTBSY => Self::ETXTBSY, + libc::EFBIG => Self::EFBIG, + libc::ENOSPC => Self::ENOSPC, + libc::ESPIPE => Self::ESPIPE, + libc::EROFS => Self::EROFS, + libc::EMLINK => Self::EMLINK, + libc::EPIPE => Self::EPIPE, + libc::EDOM => Self::EDOM, + libc::ERANGE => Self::ERANGE, + libc::EDEADLK => Self::EDEADLK, + libc::ENAMETOOLONG => Self::ENAMETOOLONG, + libc::ENOLCK => Self::ENOLCK, + libc::ENOSYS => Self::ENOSYS, + libc::ENOTEMPTY => Self::ENOTEMPTY, + libc::ELOOP => Self::ELOOP, + libc::ENOMSG => Self::ENOMSG, + libc::EIDRM => Self::EIDRM, + libc::ENOLINK => Self::ENOLINK, + libc::EPROTO => Self::EPROTO, + libc::EMULTIHOP => Self::EMULTIHOP, + libc::EBADMSG => Self::EBADMSG, + libc::EOVERFLOW => Self::EOVERFLOW, + libc::EILSEQ => Self::EILSEQ, + libc::ENOTSOCK => Self::ENOTSOCK, + libc::EDESTADDRREQ => Self::EDESTADDRREQ, + libc::EMSGSIZE => Self::EMSGSIZE, + libc::EPROTOTYPE => Self::EPROTOTYPE, + libc::ENOPROTOOPT => Self::ENOPROTOOPT, + libc::EPROTONOSUPPORT => Self::EPROTONOSUPPORT, + libc::EAFNOSUPPORT => Self::EAFNOSUPPORT, + libc::EADDRINUSE => Self::EADDRINUSE, + libc::EADDRNOTAVAIL => Self::EADDRNOTAVAIL, + libc::ENETDOWN => Self::ENETDOWN, + libc::ENETUNREACH => Self::ENETUNREACH, + libc::ENETRESET => Self::ENETRESET, + libc::ECONNABORTED => Self::ECONNABORTED, + libc::ECONNRESET => Self::ECONNRESET, + libc::ENOBUFS => Self::ENOBUFS, + libc::EISCONN => Self::EISCONN, + libc::ENOTCONN => Self::ENOTCONN, + libc::ETIMEDOUT => Self::ETIMEDOUT, + libc::ECONNREFUSED => Self::ECONNREFUSED, + libc::EHOSTUNREACH => Self::EHOSTUNREACH, + libc::EALREADY => Self::EALREADY, + libc::EINPROGRESS => Self::EINPROGRESS, + libc::ESTALE => Self::ESTALE, + libc::EDQUOT => Self::EDQUOT, + libc::ECANCELED => Self::ECANCELED, + libc::EOWNERDEAD => Self::EOWNERDEAD, + libc::ENOTRECOVERABLE => Self::ENOTRECOVERABLE, + other => { + log::warn!("Unknown errno: {}", other); + Self::ENOSYS + } + } + } + + pub fn last() -> Self { + let errno = io::Error::last_os_error() + .raw_os_error() + .unwrap_or(libc::ENOSYS); + Self::from_i32(errno) + } + + pub fn from_success_code<T: IsZero>(t: T) -> Result<()> { + if t.is_zero() { + Ok(()) + } else { + Err(Self::last().into()) + } + } + + pub fn from_result<T: IsMinusOne>(t: T) -> Result<T> { + if t.is_minus_one() { + Err(Self::last().into()) + } else { + Ok(t) + } + } +} + +impl fmt::Display for Errno { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Errno code: {}", self) + } +} + +#[doc(hidden)] +pub trait IsZero { + fn is_zero(&self) -> bool; +} + +macro_rules! impl_is_zero { + ($($t:ident)*) => ($(impl IsZero for $t { + fn is_zero(&self) -> bool { + *self == 0 + } + })*) +} + +impl_is_zero! { i32 i64 isize } + +#[doc(hidden)] +pub trait IsMinusOne { + fn is_minus_one(&self) -> bool; +} + +macro_rules! impl_is_minus_one { + ($($t:ident)*) => ($(impl IsMinusOne for $t { + fn is_minus_one(&self) -> bool { + *self == -1 + } + })*) +} + +impl_is_minus_one! { i32 i64 isize } +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +
+use crate::{ + file::{FdFlag, OFlag}, + Errno, Result, +}; +use std::os::unix::prelude::*; + +pub unsafe fn dup_fd(fd: RawFd, close_on_exec: bool) -> Result<RawFd> { + // Both fcntl commands expect a RawFd arg which will specify + // the minimum duplicated RawFd number. In our case, I don't + // think we have to worry about this that much, so passing in + // the RawFd descriptor we want duplicated + Errno::from_result(if close_on_exec { + libc::fcntl(fd, libc::F_DUPFD_CLOEXEC, fd) + } else { + libc::fcntl(fd, libc::F_DUPFD, fd) + }) +} + +pub unsafe fn get_fd_flags(fd: RawFd) -> Result<FdFlag> { + Errno::from_result(libc::fcntl(fd, libc::F_GETFD)).map(FdFlag::from_bits_truncate) +} + +pub unsafe fn set_fd_flags(fd: RawFd, flags: FdFlag) -> Result<()> { + Errno::from_success_code(libc::fcntl(fd, libc::F_SETFD, flags.bits())) +} + +pub unsafe fn get_status_flags(fd: RawFd) -> Result<OFlag> { + Errno::from_result(libc::fcntl(fd, libc::F_GETFL)).map(OFlag::from_bits_truncate) +} + +pub unsafe fn set_status_flags(fd: RawFd, flags: OFlag) -> Result<()> { + Errno::from_success_code(libc::fcntl(fd, libc::F_SETFL, flags.bits())) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +
+use crate::{Errno, Result}; +use bitflags::bitflags; +use cfg_if::cfg_if; +use std::{ + convert::TryInto, + ffi::{CString, OsStr, OsString}, + os::unix::prelude::*, +}; + +pub use crate::sys::file::*; + +bitflags! { + pub struct FdFlag: libc::c_int { + const CLOEXEC = libc::FD_CLOEXEC; + } +} + +bitflags! { + pub struct AtFlag: libc::c_int { + const REMOVEDIR = libc::AT_REMOVEDIR; + const SYMLINK_FOLLOW = libc::AT_SYMLINK_FOLLOW; + const SYMLINK_NOFOLLOW = libc::AT_SYMLINK_NOFOLLOW; + } +} + +bitflags! { + pub struct Mode: libc::mode_t { + const IRWXU = libc::S_IRWXU; + const IRUSR = libc::S_IRUSR; + const IWUSR = libc::S_IWUSR; + const IXUSR = libc::S_IXUSR; + const IRWXG = libc::S_IRWXG; + const IRGRP = libc::S_IRGRP; + const IWGRP = libc::S_IWGRP; + const IXGRP = libc::S_IXGRP; + const IRWXO = libc::S_IRWXO; + const IROTH = libc::S_IROTH; + const IWOTH = libc::S_IWOTH; + const IXOTH = libc::S_IXOTH; + const ISUID = libc::S_ISUID as libc::mode_t; + const ISGID = libc::S_ISGID as libc::mode_t; + const ISVTX = libc::S_ISVTX as libc::mode_t; + } +} + +bitflags! { + pub struct OFlag: libc::c_int { + const ACCMODE = libc::O_ACCMODE; + const APPEND = libc::O_APPEND; + const CREAT = libc::O_CREAT; + const DIRECTORY = libc::O_DIRECTORY; + const DSYNC = { + // Have to use cfg_if: https://github.com/bitflags/bitflags/issues/137 + cfg_if! { + if #[cfg(any(target_os = "android", + target_os = "ios", + target_os = "linux", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd", + target_os = "emscripten"))] { + libc::O_DSYNC + } else if #[cfg(target_os = "freebsd")] { + // https://github.com/bytecodealliance/wasmtime/pull/756 + libc::O_SYNC + } + } + }; + const EXCL = libc::O_EXCL; + #[cfg(any(target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + all(target_os = "linux", not(target_env = "musl")), + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd"))] + const FSYNC = libc::O_FSYNC; + const NOFOLLOW = libc::O_NOFOLLOW; + const NONBLOCK = libc::O_NONBLOCK; + const RDONLY = libc::O_RDONLY; + const WRONLY = libc::O_WRONLY; + const RDWR = libc::O_RDWR; + #[cfg(any(target_os = "linux", + target_os = "netbsd", + target_os = "openbsd", + target_os = "emscripten"))] + const RSYNC = libc::O_RSYNC; + const SYNC = libc::O_SYNC; + const TRUNC = libc::O_TRUNC; + } +} + +bitflags! { + pub struct SFlag: libc::mode_t { + const IFIFO = libc::S_IFIFO; + const IFCHR = libc::S_IFCHR; + const IFDIR = libc::S_IFDIR; + const IFBLK = libc::S_IFBLK; + const IFREG = libc::S_IFREG; + const IFLNK = libc::S_IFLNK; + const IFSOCK = libc::S_IFSOCK; + const IFMT = libc::S_IFMT; + } +} + +pub unsafe fn openat<P: AsRef<OsStr>>( + dirfd: RawFd, + path: P, + oflag: OFlag, + mode: Mode, +) -> Result<RawFd> { + let path = CString::new(path.as_ref().as_bytes())?; + Errno::from_result(libc::openat( + dirfd, + path.as_ptr(), + oflag.bits(), + libc::c_uint::from(mode.bits()), + )) +} + +pub unsafe fn readlinkat<P: AsRef<OsStr>>(dirfd: RawFd, path: P) -> Result<OsString> { + let path = CString::new(path.as_ref().as_bytes())?; + let buffer = &mut [0u8; libc::PATH_MAX as usize + 1]; + Errno::from_result(libc::readlinkat( + dirfd, + path.as_ptr(), + buffer.as_mut_ptr() as *mut _, + buffer.len(), + )) + .and_then(|nread| { + let link = OsStr::from_bytes(&buffer[0..nread.try_into()?]); + Ok(link.into()) + }) +} + +pub unsafe fn mkdirat<P: AsRef<OsStr>>(dirfd: RawFd, path: P, mode: Mode) -> Result<()> { + let path = CString::new(path.as_ref().as_bytes())?; + Errno::from_success_code(libc::mkdirat(dirfd, path.as_ptr(), mode.bits())) +} + +pub unsafe fn linkat<P: AsRef<OsStr>>( + old_dirfd: RawFd, + old_path: P, + new_dirfd: RawFd, + new_path: P, + flags: AtFlag, +) -> Result<()> { + let old_path = CString::new(old_path.as_ref().as_bytes())?; + let new_path = CString::new(new_path.as_ref().as_bytes())?; + Errno::from_success_code(libc::linkat( + old_dirfd, + old_path.as_ptr(), + new_dirfd, + new_path.as_ptr(), + flags.bits(), + )) +} + +pub unsafe fn unlinkat<P: AsRef<OsStr>>(dirfd: RawFd, path: P, flags: AtFlag) -> Result<()> { + let path = CString::new(path.as_ref().as_bytes())?; + Errno::from_success_code(libc::unlinkat(dirfd, path.as_ptr(), flags.bits())) +} + +pub unsafe fn renameat<P: AsRef<OsStr>>( + old_dirfd: RawFd, + old_path: P, + new_dirfd: RawFd, + new_path: P, +) -> Result<()> { + let old_path = CString::new(old_path.as_ref().as_bytes())?; + let new_path = CString::new(new_path.as_ref().as_bytes())?; + Errno::from_success_code(libc::renameat( + old_dirfd, + old_path.as_ptr(), + new_dirfd, + new_path.as_ptr(), + )) +} + +pub unsafe fn symlinkat<P: AsRef<OsStr>>(old_path: P, new_dirfd: RawFd, new_path: P) -> Result<()> { + let old_path = CString::new(old_path.as_ref().as_bytes())?; + let new_path = CString::new(new_path.as_ref().as_bytes())?; + Errno::from_success_code(libc::symlinkat( + old_path.as_ptr(), + new_dirfd, + new_path.as_ptr(), + )) +} + +pub unsafe fn fstatat<P: AsRef<OsStr>>(dirfd: RawFd, path: P, flags: AtFlag) -> Result<libc::stat> { + use std::mem::MaybeUninit; + let path = CString::new(path.as_ref().as_bytes())?; + let mut filestat = MaybeUninit::<libc::stat>::uninit(); + Errno::from_result(libc::fstatat( + dirfd, + path.as_ptr(), + filestat.as_mut_ptr(), + flags.bits(), + ))?; + Ok(filestat.assume_init()) +} + +pub unsafe fn fstat(fd: RawFd) -> Result<libc::stat> { + use std::mem::MaybeUninit; + let mut filestat = MaybeUninit::<libc::stat>::uninit(); + Errno::from_result(libc::fstat(fd, filestat.as_mut_ptr()))?; + Ok(filestat.assume_init()) +} + +/// `fionread()` function, equivalent to `ioctl(fd, FIONREAD, *bytes)`. +pub unsafe fn fionread(fd: RawFd) -> Result<usize> { + let mut nread: libc::c_int = 0; + Errno::from_result(libc::ioctl(fd, libc::FIONREAD, &mut nread as *mut _))?; + Ok(nread.try_into()?) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +
+//! `yanix` stands for Yet Another Nix crate, and, well, it is simply +//! a yet another crate in the spirit of the [nix] crate. As such, +//! this crate is inspired by the original `nix` crate, however, +//! it takes a different approach, using lower-level interfaces with +//! less abstraction, so that it fits better with its main use case +//! which is our WASI implementation, [wasi-common]. +//! +//! [nix]: https://github.com/nix-rust/nix +//! [wasi-common]: https://github.com/bytecodealliance/wasmtime/tree/master/crates/wasi-common +#![cfg(unix)] + +pub mod clock; +pub mod dir; +pub mod fcntl; +pub mod file; +pub mod poll; +pub mod socket; + +mod errno; +mod sys; + +pub mod fadvise { + pub use super::sys::fadvise::*; +} + +pub use errno::Errno; +use std::{ffi, num}; +use thiserror::Error; + +pub type Result<T> = std::result::Result<T, YanixError>; + +#[derive(Debug, Error)] +pub enum YanixError { + #[error("raw os error {0}")] + Errno(#[from] Errno), + #[error("a nul byte was not found in the expected position")] + NulError(#[from] ffi::NulError), + #[error("integral type conversion failed")] + TryFromIntError(#[from] num::TryFromIntError), +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +
+use crate::{Errno, Result}; +use bitflags::bitflags; +use std::{convert::TryInto, os::unix::prelude::*}; + +bitflags! { + pub struct PollFlags: libc::c_short { + const POLLIN = libc::POLLIN; + const POLLPRI = libc::POLLPRI; + const POLLOUT = libc::POLLOUT; + const POLLRDNORM = libc::POLLRDNORM; + const POLLWRNORM = libc::POLLWRNORM; + const POLLRDBAND = libc::POLLRDBAND; + const POLLWRBAND = libc::POLLWRBAND; + const POLLERR = libc::POLLERR; + const POLLHUP = libc::POLLHUP; + const POLLNVAL = libc::POLLNVAL; + } +} + +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] +#[repr(C)] +pub struct PollFd(libc::pollfd); + +impl PollFd { + pub unsafe fn new(fd: RawFd, events: PollFlags) -> Self { + Self(libc::pollfd { + fd, + events: events.bits(), + revents: PollFlags::empty().bits(), + }) + } + + pub fn revents(self) -> Option<PollFlags> { + PollFlags::from_bits(self.0.revents) + } +} + +pub fn poll(fds: &mut [PollFd], timeout: libc::c_int) -> Result<usize> { + Errno::from_result(unsafe { + libc::poll( + fds.as_mut_ptr() as *mut libc::pollfd, + fds.len() as libc::nfds_t, + timeout, + ) + }) + .and_then(|nready| nready.try_into().map_err(Into::into)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +
+use crate::{Errno, Result}; +use std::os::unix::prelude::*; + +#[derive(Debug, Clone, Copy)] +#[repr(i32)] +pub enum SockType { + Stream = libc::SOCK_STREAM, + Datagram = libc::SOCK_DGRAM, + SeqPacket = libc::SOCK_SEQPACKET, + Raw = libc::SOCK_RAW, + Rdm = libc::SOCK_RDM, +} + +pub unsafe fn get_socket_type(fd: RawFd) -> Result<SockType> { + use std::mem::{self, MaybeUninit}; + let mut buffer = MaybeUninit::<SockType>::zeroed().assume_init(); + let mut out_len = mem::size_of::<SockType>() as libc::socklen_t; + Errno::from_success_code(libc::getsockopt( + fd, + libc::SOL_SOCKET, + libc::SO_TYPE, + &mut buffer as *mut SockType as *mut _, + &mut out_len, + ))?; + assert_eq!( + out_len as usize, + mem::size_of::<SockType>(), + "invalid SockType value" + ); + Ok(buffer) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +
+use crate::{ + dir::{Dir, Entry, EntryExt, SeekLoc}, + Errno, Result, +}; +use std::ops::Deref; + +#[derive(Copy, Clone, Debug)] +pub(crate) struct EntryImpl(libc::dirent64); + +impl Deref for EntryImpl { + type Target = libc::dirent64; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl EntryExt for Entry { + fn ino(&self) -> u64 { + self.0.d_ino.into() + } + + fn seek_loc(&self) -> Result<SeekLoc> { + unsafe { SeekLoc::from_raw(self.0.d_off) } + } +} + +pub(crate) fn iter_impl(dir: &Dir) -> Option<Result<EntryImpl>> { + let errno = Errno::last(); + let dirent = unsafe { libc::readdir64(dir.as_raw().as_ptr()) }; + if dirent.is_null() { + if errno != Errno::last() { + // TODO This should be verified on different BSD-flavours. + // + // According to 4.3BSD/POSIX.1-2001 man pages, there was an error + // if the errno value has changed at some point during the sequence + // of readdir calls. + Some(Err(Errno::last().into())) + } else { + // Not an error. We've simply reached the end of the stream. + None + } + } else { + Some(Ok(EntryImpl(unsafe { *dirent }))) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +
+use crate::{Errno, Result}; +use std::os::unix::prelude::*; + +#[derive(Debug, Copy, Clone)] +#[repr(i32)] +pub enum PosixFadviseAdvice { + Normal = libc::POSIX_FADV_NORMAL, + Sequential = libc::POSIX_FADV_SEQUENTIAL, + Random = libc::POSIX_FADV_RANDOM, + NoReuse = libc::POSIX_FADV_NOREUSE, + WillNeed = libc::POSIX_FADV_WILLNEED, + DontNeed = libc::POSIX_FADV_DONTNEED, +} + +pub unsafe fn posix_fadvise( + fd: RawFd, + offset: libc::off_t, + len: libc::off_t, + advice: PosixFadviseAdvice, +) -> Result<()> { + Errno::from_success_code(libc::posix_fadvise(fd, offset, len, advice as libc::c_int)) +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +
+use crate::{Errno, Result}; +use std::os::unix::prelude::*; + +pub unsafe fn isatty(fd: RawFd) -> Result<bool> { + let res = libc::isatty(fd); + if res == 1 { + // isatty() returns 1 if fd is an open file descriptor referring to a terminal... + Ok(true) + } else { + // ... otherwise 0 is returned, and errno is set to indicate the error. + let errno = Errno::last(); + // While POSIX specifies ENOTTY if the passed + // fd is *not* a tty, on Linux, some implementations + // may return EINVAL instead. + // + // https://linux.die.net/man/3/isatty + if errno == Errno::ENOTTY || errno == Errno::EINVAL { + Ok(false) + } else { + Err(errno.into()) + } + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +
+pub(crate) mod dir; +pub(crate) mod fadvise; +pub(crate) mod file; + +use crate::{dir::SeekLoc, Result}; + +impl SeekLoc { + pub unsafe fn from_raw(loc: i64) -> Result<Self> { + let loc = loc.into(); + Ok(Self(loc)) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +
+use crate::{dir::SeekLoc, Result}; +use cfg_if::cfg_if; + +cfg_if! { + if #[cfg(any(target_os = "linux", + target_os = "android"))] { + mod linux; + pub(crate) use linux::*; + } else if #[cfg(target_os = "emscripten")] { + mod emscripten; + pub(crate) use emscripten::*; + } else if #[cfg(any(target_os = "macos", + target_os = "ios", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd", + target_os = "dragonfly"))] { + mod bsd; + pub(crate) use bsd::*; + } else { + compile_error!("yanix doesn't compile for this platform yet"); + } +} + +pub trait EntryExt { + fn ino(&self) -> u64; + fn seek_loc(&self) -> Result<SeekLoc>; +} +
Redirecting to ../../wasi_common/struct.WasiCtx.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/ctx/struct.WasiCtxBuilder.html b/api/wasi_common/ctx/struct.WasiCtxBuilder.html new file mode 100644 index 000000000000..4bf0b1ed2a0f --- /dev/null +++ b/api/wasi_common/ctx/struct.WasiCtxBuilder.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasi_common/struct.WasiCtxBuilder.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/enum.Error.html b/api/wasi_common/enum.Error.html new file mode 100644 index 000000000000..142cad60a4ac --- /dev/null +++ b/api/wasi_common/enum.Error.html @@ -0,0 +1,32 @@ +Io(Error)Yanix(YanixError)impl Error[src]pub const ESUCCESS: Self[src]pub const E2BIG: Self[src]pub const EACCES: Self[src]pub const EADDRINUSE: Self[src]pub const EADDRNOTAVAIL: Self[src]pub const EAFNOSUPPORT: Self[src]pub const EAGAIN: Self[src]pub const EALREADY: Self[src]pub const EBADF: Self[src]pub const EBADMSG: Self[src]pub const EBUSY: Self[src]pub const ECANCELED: Self[src]pub const ECHILD: Self[src]pub const ECONNABORTED: Self[src]pub const ECONNREFUSED: Self[src]pub const ECONNRESET: Self[src]pub const EDEADLK: Self[src]pub const EDESTADDRREQ: Self[src]pub const EDOM: Self[src]pub const EDQUOT: Self[src]pub const EEXIST: Self[src]pub const EFAULT: Self[src]pub const EFBIG: Self[src]pub const EHOSTUNREACH: Self[src]pub const EIDRM: Self[src]pub const EILSEQ: Self[src]pub const EINPROGRESS: Self[src]pub const EINTR: Self[src]pub const EINVAL: Self[src]pub const EIO: Self[src]pub const EISCONN: Self[src]pub const EISDIR: Self[src]pub const ELOOP: Self[src]pub const EMFILE: Self[src]pub const EMLINK: Self[src]pub const EMSGSIZE: Self[src]pub const EMULTIHOP: Self[src]pub const ENAMETOOLONG: Self[src]pub const ENETDOWN: Self[src]pub const ENETRESET: Self[src]pub const ENETUNREACH: Self[src]pub const ENFILE: Self[src]pub const ENOBUFS: Self[src]pub const ENODEV: Self[src]pub const ENOENT: Self[src]pub const ENOEXEC: Self[src]pub const ENOLCK: Self[src]pub const ENOLINK: Self[src]pub const ENOMEM: Self[src]pub const ENOMSG: Self[src]pub const ENOPROTOOPT: Self[src]pub const ENOSPC: Self[src]pub const ENOSYS: Self[src]pub const ENOTCONN: Self[src]pub const ENOTDIR: Self[src]pub const ENOTEMPTY: Self[src]pub const ENOTRECOVERABLE: Self[src]pub const ENOTSOCK: Self[src]pub const ENOTSUP: Self[src]pub const ENOTTY: Self[src]pub const ENXIO: Self[src]pub const EOVERFLOW: Self[src]pub const EOWNERDEAD: Self[src]pub const EPERM: Self[src]pub const EPIPE: Self[src]pub const EPROTO: Self[src]pub const EPROTONOSUPPORT: Self[src]pub const EPROTOTYPE: Self[src]pub const ERANGE: Self[src]pub const EROFS: Self[src]pub const ESPIPE: Self[src]pub const ESRCH: Self[src]pub const ESTALE: Self[src]pub const ETIMEDOUT: Self[src]pub const ETXTBSY: Self[src]pub const EXDEV: Self[src]pub const ENOTCAPABLE: Self[src]impl Debug for Error[src]impl Display for Error[src]impl Error for Error[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl<'_> From<&'_ NulError> for Error[src]impl From<Errno> for Error[src]impl From<Error> for Error[src]impl From<Infallible> for Error[src]fn from(_: Infallible) -> Self[src]impl From<NulError> for Error[src]impl From<TryFromIntError> for Error[src]fn from(_: TryFromIntError) -> Self[src]impl From<Utf8Error> for Error[src]impl From<YanixError> for Error[src]fn from(source: YanixError) -> Self[src]impl !RefUnwindSafe for Errorimpl Send for Errorimpl Sync for Errorimpl Unpin for Errorimpl !UnwindSafe for Errorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasi_common/enum.Error.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fn.preopen_dir.html b/api/wasi_common/fn.preopen_dir.html new file mode 100644 index 000000000000..1c1d40c02df1 --- /dev/null +++ b/api/wasi_common/fn.preopen_dir.html @@ -0,0 +1 @@ +pub fn preopen_dir<P: AsRef<Path>>(path: P) -> Result<File, Error>
Redirecting to ../../../wasi_common/fs/struct.Dir.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/dir_builder/struct.DirBuilder.html b/api/wasi_common/fs/dir_builder/struct.DirBuilder.html new file mode 100644 index 000000000000..99ebd46612fc --- /dev/null +++ b/api/wasi_common/fs/dir_builder/struct.DirBuilder.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.DirBuilder.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/dir_entry/struct.DirEntry.html b/api/wasi_common/fs/dir_entry/struct.DirEntry.html new file mode 100644 index 000000000000..87926e5bd7a4 --- /dev/null +++ b/api/wasi_common/fs/dir_entry/struct.DirEntry.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.DirEntry.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/file/struct.File.html b/api/wasi_common/fs/file/struct.File.html new file mode 100644 index 000000000000..7091c768fbf9 --- /dev/null +++ b/api/wasi_common/fs/file/struct.File.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.File.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/file_type/struct.FileType.html b/api/wasi_common/fs/file_type/struct.FileType.html new file mode 100644 index 000000000000..79c29b3fb10c --- /dev/null +++ b/api/wasi_common/fs/file_type/struct.FileType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.FileType.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/index.html b/api/wasi_common/fs/index.html new file mode 100644 index 000000000000..cd3250deaa31 --- /dev/null +++ b/api/wasi_common/fs/index.html @@ -0,0 +1,24 @@ +A very experimental module modeled providing a high-level and safe
+filesystem interface, modeled after std::fs, implemented on top of
+WASI functions.
Most functions in this API are not yet implemented!
+This corresponds to std::fs.
Instead of std::fs's free functions which operate on paths, this
+crate has methods on Dir which operate on paths which must be
+relative to and within the directory.
Since all functions which expose raw file descriptors are unsafe,
+I/O handles in this API are unforgeable (unsafe code notwithstanding).
+This combined with WASI's lack of absolute paths provides a natural
+capability-oriented interface.
| Dir | A reference to an open directory on the filesystem. + |
| DirBuilder | A builder used to create directories in various manners. + |
| DirEntry | Entries returned by the ReadDir iterator. + |
| File | A reference to an open file on the filesystem. + |
| FileType | A structure representing a type of file with accessors for each file type.
+It is returned by |
| Metadata | Metadata information about a file. + |
| OpenOptions | Options and flags which can be used to configure how a file is opened. + |
| Permissions | Representation of the various permissions on a file. + |
| ReadDir | Iterator over the entries in a directory. + |
Redirecting to ../../../wasi_common/fs/struct.Metadata.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/open_options/struct.OpenOptions.html b/api/wasi_common/fs/open_options/struct.OpenOptions.html new file mode 100644 index 000000000000..a1da1bb12123 --- /dev/null +++ b/api/wasi_common/fs/open_options/struct.OpenOptions.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.OpenOptions.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/permissions/struct.Permissions.html b/api/wasi_common/fs/permissions/struct.Permissions.html new file mode 100644 index 000000000000..8a694ab4367e --- /dev/null +++ b/api/wasi_common/fs/permissions/struct.Permissions.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.Permissions.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/readdir/struct.ReadDir.html b/api/wasi_common/fs/readdir/struct.ReadDir.html new file mode 100644 index 000000000000..8571a1a2f995 --- /dev/null +++ b/api/wasi_common/fs/readdir/struct.ReadDir.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasi_common/fs/struct.ReadDir.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/fs/sidebar-items.js b/api/wasi_common/fs/sidebar-items.js new file mode 100644 index 000000000000..f699547cc2b6 --- /dev/null +++ b/api/wasi_common/fs/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"struct":[["Dir","A reference to an open directory on the filesystem."],["DirBuilder","A builder used to create directories in various manners."],["DirEntry","Entries returned by the ReadDir iterator."],["File","A reference to an open file on the filesystem."],["FileType","A structure representing a type of file with accessors for each file type. It is returned by `Metadata::file_type` method."],["Metadata","Metadata information about a file."],["OpenOptions","Options and flags which can be used to configure how a file is opened."],["Permissions","Representation of the various permissions on a file."],["ReadDir","Iterator over the entries in a directory."]]}); \ No newline at end of file diff --git a/api/wasi_common/fs/struct.Dir.html b/api/wasi_common/fs/struct.Dir.html new file mode 100644 index 000000000000..aac0f02b15da --- /dev/null +++ b/api/wasi_common/fs/struct.Dir.html @@ -0,0 +1,51 @@ +A reference to an open directory on the filesystem.
+TODO: Implement Dir-using versions of std::fs's free functions:
+copy, create_dir, create_dir_all, hard_link, metadata,
+read_link, read_to_string, remove_dir, remove_dir_all,
+remove_file, rename, set_permissions, symlink_metadata, and
+write.
Unlike std::fs, this API has no canonicalize, because absolute paths
+don't interoperate well with the capability-oriented security model.
impl<'ctx> Dir<'ctx>[src]pub unsafe fn from_raw_wasi_fd(ctx: &'ctx mut WasiCtx, fd: __wasi_fd_t) -> Self[src]Constructs a new instance of Self from the given raw WASI file descriptor.
pub fn open_file<P: AsRef<Path>>(&mut self, path: P) -> Result<File>[src]Attempts to open a file in read-only mode.
+This corresponds to std::fs::File::open, but only accesses paths
+relative to and within self.
TODO: Not yet implemented. Refactor the hostcalls functions to split out the +encoding/decoding parts from the underlying functionality, so that we can call +into the underlying functionality directly.
+pub fn open_file_with<P: AsRef<Path>>(
&mut self,
path: P,
options: &OpenOptions
) -> Result<File>[src]Opens a file at path with the options specified by self.
This corresponds to std::fs::OpenOptions::open.
Instead of being a method on OpenOptions, this is a method on Dir,
+and it only accesses functions relative to and within self.
TODO: Not yet implemented.
+pub fn open_dir<P: AsRef<Path>>(&mut self, path: P) -> Result<Self>[src]Attempts to open a directory.
+TODO: Not yet implemented. See the comment in open_file.
pub fn create_file<P: AsRef<Path>>(&mut self, path: P) -> Result<File>[src]Opens a file in write-only mode.
+This corresponds to std::fs::File::create, but only accesses paths
+relative to and within self.
TODO: Not yet implemented. See the comment in open_file.
pub fn read(&mut self) -> Result<ReadDir>[src]Returns an iterator over the entries within a directory.
+This corresponds to std::fs::read_dir, but reads the directory
+represented by self.
TODO: Not yet implemented. We may need to wait until we have the ability
+to duplicate file descriptors before we can implement read safely. For
+now, use into_read instead.
pub fn into_read(self) -> ReadDir[src]Consumes self and returns an iterator over the entries within a directory
+in the manner of read.
pub fn read_file<P: AsRef<Path>>(&mut self, path: P) -> Result<Vec<u8>>[src]Read the entire contents of a file into a bytes vector.
+This corresponds to std::fs::read, but only accesses paths
+relative to and within self.
pub fn read_dir<P: AsRef<Path>>(&mut self, path: P) -> Result<ReadDir>[src]Returns an iterator over the entries within a directory.
+This corresponds to std::fs::read_dir, but only accesses paths
+relative to and within self.
impl<'ctx> RefUnwindSafe for Dir<'ctx>impl<'ctx> Send for Dir<'ctx>impl<'ctx> Sync for Dir<'ctx>impl<'ctx> Unpin for Dir<'ctx>impl<'ctx> !UnwindSafe for Dir<'ctx>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A builder used to create directories in various manners.
+This corresponds to std::fs::DirBuilder.
TODO: Not yet implemented.
+impl DirBuilder[src]pub fn new() -> Self[src]Creates a new set of options with default mode/security settings for all platforms and also non-recursive.
+This corresponds to std::fs::DirBuilder::new.
TODO: Not yet implemented.
+pub fn recursive(&mut self, recursive: bool) -> &mut Self[src]Indicates that directories should be created recursively, creating all parent directories.
+This corresponds to std::fs::DirBuilder::recursive.
TODO: Not yet implemented.
+pub fn create<P: AsRef<Path>>(&self, path: P) -> Result<()>[src]Creates the specified directory with the options configured in this builder.
+This corresponds to std::fs::DirBuilder::create.
TODO: Not yet implemented.
+impl RefUnwindSafe for DirBuilderimpl Send for DirBuilderimpl Sync for DirBuilderimpl Unpin for DirBuilderimpl UnwindSafe for DirBuilderimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Entries returned by the ReadDir iterator.
+This corresponds to std::fs::DirEntry.
Unlike std::fs::DirEntry, this API has no DirEntry::path, because
+absolute paths don't interoperate well with the capability-oriented
+security model.
TODO: Not yet implemented.
+impl DirEntry[src]pub fn metadata(&self) -> Result<Metadata>[src]Returns the metadata for the file that this entry points at.
+This corresponds to std::fs::DirEntry::metadata.
TODO: Not yet implemented.
+pub fn file_type(&self) -> Result<FileType>[src]Returns the file type for the file that this entry points at.
+This to std::fs::DirEntry::file_type.
TODO: Not yet implemented.
+pub fn file_name(&self) -> String[src]Returns the bare file name of this directory entry without any other leading path component.
+This corresponds to std::fs::DirEntry::file_name, though it returns
+String rather than OsString.
TODO: Not yet implemented.
+impl RefUnwindSafe for DirEntryimpl Send for DirEntryimpl Sync for DirEntryimpl Unpin for DirEntryimpl UnwindSafe for DirEntryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A reference to an open file on the filesystem.
+This corresponds to std::fs::File.
Note that this File has no open or create methods. To open or create
+a file, you must first obtain a Dir containing the file, and then call
+Dir::open_file or Dir::create_file.
impl<'ctx> File<'ctx>[src]pub unsafe fn from_raw_wasi_fd(ctx: &'ctx mut WasiCtx, fd: __wasi_fd_t) -> Self[src]Constructs a new instance of Self from the given raw WASI file descriptor.
This corresponds to std::fs::File::from_raw_fd.
pub fn sync_all(&self) -> Result<(), Error>[src]Attempts to sync all OS-internal metadata to disk.
+This corresponds to std::fs::File::sync_all.
pub fn sync_data(&self) -> Result<(), Error>[src]This function is similar to sync_all, except that it may not synchronize
+file metadata to the filesystem.
This corresponds to std::fs::File::sync_data.
pub fn set_len(&self, size: u64) -> Result<(), Error>[src]Truncates or extends the underlying file, updating the size of this file +to become size.
+This corresponds to std::fs::File::set_len.
pub fn metadata(&self) -> Result<Metadata, Error>[src]Queries metadata about the underlying file.
+This corresponds to std::fs::File::metadata.
impl<'ctx> Drop for File<'ctx>[src]impl<'ctx> Read for File<'ctx>[src]fn read(&mut self, buf: &mut [u8]) -> Result<usize>[src]TODO: Not yet implemented. See the comment in Dir::open_file.
fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>1.36.0[src]unsafe fn initializer(&self) -> Initializer[src]fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>1.0.0[src]fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>1.0.0[src]fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>1.6.0[src]fn by_ref(&mut self) -> &mut Self1.0.0[src]fn bytes(self) -> Bytes<Self>1.0.0[src]fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read, 1.0.0[src]fn take(self, limit: u64) -> Take<Self>1.0.0[src]impl<'ctx> RefUnwindSafe for File<'ctx>impl<'ctx> Send for File<'ctx>impl<'ctx> Sync for File<'ctx>impl<'ctx> Unpin for File<'ctx>impl<'ctx> !UnwindSafe for File<'ctx>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A structure representing a type of file with accessors for each file type.
+It is returned by Metadata::file_type method.
This corresponds to std::fs::FileType.
TODO: Not yet implemented.
+impl FileType[src]pub fn is_dir(&self) -> bool[src]Tests whether this file type represents a directory.
+This corresponds to std::fs::FileType::is_dir.
TODO: Not yet implemented.
+pub fn is_file(&self) -> bool[src]Tests whether this file type represents a regular file.
+This corresponds to std::fs::FileType::is_file.
TODO: Not yet implemented.
+pub fn is_symlink(&self) -> bool[src]Tests whether this file type represents a symbolic link.
+This corresponds to std::fs::FileType::is_symlink.
TODO: Not yet implemented.
+impl Clone for FileType[src]impl Copy for FileType[src]impl Eq for FileType[src]impl Hash for FileType[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<FileType> for FileType[src]impl StructuralEq for FileType[src]impl StructuralPartialEq for FileType[src]impl RefUnwindSafe for FileTypeimpl Send for FileTypeimpl Sync for FileTypeimpl Unpin for FileTypeimpl UnwindSafe for FileTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Metadata information about a file.
+This corresponds to std::fs::Metadata.
TODO: Not yet implemented.
+impl Metadata[src]pub fn file_type(&self) -> FileType[src]Returns the file type for this metadata.
+This corresponds to std::fs::Metadata::file_type.
TODO: Not yet implemented.
+pub fn is_dir(&self) -> bool[src]Returns true if this metadata is for a directory.
+This corresponds to std::fs::Metadata::is_dir.
TODO: Not yet implemented.
+pub fn is_file(&self) -> bool[src]Returns true if this metadata is for a regular file.
+This corresponds to std::fs::Metadata::is_file.
TODO: Not yet implemented.
+pub fn len(&self) -> u64[src]Returns the size of the file, in bytes, this metadata is for.
+This corresponds to std::fs::Metadata::len.
TODO: Not yet implemented.
+pub fn permissions(&self) -> Permissions[src]Returns the permissions of the file this metadata is for.
+This corresponds to std::fs::Metadata::permissions.
TODO: Not yet implemented.
+pub fn modified(&self) -> Result<SystemTime>[src]Returns the last modification time listed in this metadata.
+This corresponds to std::fs::Metadata::modified.
TODO: Not yet implemented.
+pub fn accessed(&self) -> Result<SystemTime>[src]Returns the last access time of this metadata.
+This corresponds to std::fs::Metadata::accessed.
TODO: Not yet implemented.
+pub fn created(&self) -> Result<SystemTime>[src]Returns the creation time listed in this metadata.
+This corresponds to std::fs::Metadata::created.
TODO: Not yet implemented.
+impl RefUnwindSafe for Metadataimpl Send for Metadataimpl Sync for Metadataimpl Unpin for Metadataimpl UnwindSafe for Metadataimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Options and flags which can be used to configure how a file is opened.
+This corresponds to std::fs::OpenOptions.
Note that this OpenOptions has no open method. To open a file with
+an OptionOptions, you must first obtain a Dir containing the file, and
+then call Dir::open_file_with.
impl OpenOptions[src]pub fn new() -> Self[src]Creates a blank new set of options ready for configuration.
+This corresponds to std::fs::OpenOptions::new.
pub fn read(&mut self, read: bool) -> &mut Self[src]Sets the option for read access.
+This corresponds to std::fs::OpenOptions::read.
pub fn write(&mut self, write: bool) -> &mut Self[src]Sets the option for write access.
+This corresponds to std::fs::OpenOptions::write.
pub fn append(&mut self, append: bool) -> &mut Self[src]Sets the option for the append mode.
+This corresponds to std::fs::OpenOptions::append.
pub fn truncate(&mut self, truncate: bool) -> &mut Self[src]Sets the option for truncating a previous file.
+This corresponds to std::fs::OpenOptions::truncate.
pub fn create(&mut self, create: bool) -> &mut Self[src]Sets the option to create a new file.
+This corresponds to std::fs::OpenOptions::create.
pub fn create_new(&mut self, create_new: bool) -> &mut Self[src]Sets the option to always create a new file.
+This corresponds to std::fs::OpenOptions::create_new.
impl RefUnwindSafe for OpenOptionsimpl Send for OpenOptionsimpl Sync for OpenOptionsimpl Unpin for OpenOptionsimpl UnwindSafe for OpenOptionsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Representation of the various permissions on a file.
+This corresponds to std::fs::Permissions.
TODO: Not yet implemented.
+impl Permissions[src]pub fn readonly(&self) -> bool[src]Returns true if these permissions describe a readonly (unwritable) file.
+This corresponds to std::fs::Permissions::readonly.
TODO: Not yet implemented.
+pub fn set_readonly(&mut self, readonly: bool)[src]Modifies the readonly flag for this set of permissions.
+This corresponds to std::fs::Permissions::set_readonly.
TODO: Not yet implemented.
+impl Clone for Permissions[src]fn clone(&self) -> Permissions[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Eq for Permissions[src]impl PartialEq<Permissions> for Permissions[src]fn eq(&self, other: &Permissions) -> bool[src]#[must_use]
+fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for Permissions[src]impl StructuralPartialEq for Permissions[src]impl RefUnwindSafe for Permissionsimpl Send for Permissionsimpl Sync for Permissionsimpl Unpin for Permissionsimpl UnwindSafe for Permissionsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Iterator over the entries in a directory.
+This corresponds to std::fs::ReadDir.
TODO: Not yet implemented.
+impl ReadDir[src]pub unsafe fn from_raw_wasi_fd(fd: __wasi_fd_t) -> Self[src]Constructs a new instance of Self from the given raw WASI file descriptor.
impl Iterator for ReadDir[src]TODO: Not yet implemented.
+type Item = DirEntryThe type of the elements being iterated over.
+fn next(&mut self) -> Option<Self::Item>[src]TODO: Not yet implemented.
+fn size_hint(&self) -> (usize, Option<usize>)1.0.0[src]fn count(self) -> usize1.0.0[src]fn last(self) -> Option<Self::Item>1.0.0[src]fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[src]fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>, 1.0.0[src]fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator, 1.0.0[src]fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, 1.0.0[src]fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), 1.21.0[src]fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]fn enumerate(self) -> Enumerate<Self>1.0.0[src]fn peekable(self) -> Peekable<Self>1.0.0[src]fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>, [src]fn skip(self, n: usize) -> Skip<Self>1.0.0[src]fn take(self, n: usize) -> Take<Self>1.0.0[src]fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator, 1.0.0[src]fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator, 1.29.0[src]fn fuse(self) -> Fuse<Self>1.0.0[src]fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), 1.0.0[src]fn by_ref(&mut self) -> &mut Self1.0.0[src]#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
+fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, 1.0.0[src]fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, 1.0.0[src]fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a, [src]fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0[src]fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, 1.27.0[src]fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, 1.0.0[src]fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>, [src]fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, 1.0.0[src]fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, 1.0.0[src]fn max(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]fn min(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator, 1.0.0[src]fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, 1.0.0[src]fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, 1.36.0[src]fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, 1.0.0[src]fn cycle(self) -> Cycle<Self> where
Self: Clone, 1.0.0[src]fn sum<S>(self) -> S where
S: Sum<Self::Item>, 1.11.0[src]fn product<P>(self) -> P where
P: Product<Self::Item>, 1.11.0[src]fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, 1.5.0[src]fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]impl RefUnwindSafe for ReadDirimpl Send for ReadDirimpl Sync for ReadDirimpl Unpin for ReadDirimpl UnwindSafe for ReadDirimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<I> IntoIterator for I where
I: Iterator, [src]type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
+type IntoIter = IWhich kind of iterator are we turning this into?
+fn into_iter(self) -> I[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub unsafe fn args_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argv: uintptr_t,
argv_buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn args_sizes_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
pub unsafe fn clock_res_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
id: __wasi_clockid_t,
resolution: uintptr_t
) -> __wasi_errno_t
pub unsafe fn clock_time_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
id: __wasi_clockid_t,
precision: __wasi_timestamp_t,
time: uintptr_t
) -> __wasi_errno_t
pub unsafe fn environ_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
environ: uintptr_t,
environ_buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn environ_sizes_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_advise(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t,
advice: __wasi_advice_t
) -> __wasi_errno_t
pub unsafe fn fd_allocate(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t
) -> __wasi_errno_t
pub unsafe fn fd_close(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_datasync(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
stat: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_set_flags(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_fdflags_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_set_rights(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inheriting: __wasi_rights_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_set_size(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
size: __wasi_filesize_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_set_times(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
pub unsafe fn fd_pread(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nread: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_prestat_dir_name(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn fd_prestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_pwrite(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nwritten: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_read(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nread: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_readdir(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t,
buf_len: size_t,
cookie: __wasi_dircookie_t,
bufused: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_renumber(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
to: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_seek(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filedelta_t,
whence: __wasi_whence_t,
newoffset: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_sync(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_tell(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_write(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nwritten: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_create_directory(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_filestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_filestat_set_times(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
pub unsafe fn path_link(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
old_fd: __wasi_fd_t,
old_flags: __wasi_lookupflags_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_open(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
dirflags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
oflags: __wasi_oflags_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inherting: __wasi_rights_t,
fdflags: __wasi_fdflags_t,
opened_fd: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_readlink(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t,
buf_len: size_t,
bufused: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_remove_directory(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_rename(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_symlink(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
old_path_ptr: uintptr_t,
old_path_len: size_t,
fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_unlink_file(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn poll_oneoff(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
r#in: uintptr_t,
out: uintptr_t,
nsubscriptions: size_t,
nevents: uintptr_t
) -> __wasi_errno_t
pub unsafe fn proc_exit(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
rval: __wasi_exitcode_t
)
pub unsafe fn proc_raise(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
sig: __wasi_signal_t
) -> __wasi_errno_t
pub unsafe fn random_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
buf: uintptr_t,
buf_len: size_t
) -> __wasi_errno_t
pub unsafe fn sched_yield(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8]
) -> __wasi_errno_t
pub unsafe fn sock_recv(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
ri_data_ptr: uintptr_t,
ri_data_len: size_t,
ri_flags: __wasi_riflags_t,
ro_datalen: uintptr_t,
ro_flags: uintptr_t
) -> __wasi_errno_t
pub unsafe fn sock_send(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
si_data_ptr: uintptr_t,
si_data_len: size_t,
si_flags: __wasi_siflags_t,
so_datalen: uintptr_t
) -> __wasi_errno_t
pub unsafe fn sock_shutdown(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
how: __wasi_sdflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_args_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argv: uintptr_t,
argv_buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_args_sizes_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_clock_res_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
id: __wasi_clockid_t,
resolution: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_clock_time_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
id: __wasi_clockid_t,
precision: __wasi_timestamp_t,
time: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_environ_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
environ: uintptr_t,
environ_buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_environ_sizes_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_advise(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t,
advice: __wasi_advice_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_allocate(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_close(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_datasync(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_fdstat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
stat: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_fdstat_set_flags(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_fdflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_fdstat_set_rights(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inheriting: __wasi_rights_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_filestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_filestat_set_size(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
size: __wasi_filesize_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_filestat_set_times(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_pread(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nread: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_prestat_dir_name(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_prestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_pwrite(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nwritten: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_read(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nread: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_readdir(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t,
buf_len: size_t,
cookie: __wasi_dircookie_t,
bufused: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_renumber(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
to: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_seek(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filedelta_t,
whence: __wasi_whence_t,
newoffset: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_sync(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_tell(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_fd_write(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nwritten: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_create_directory(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_filestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_filestat_set_times(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_link(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
old_fd: __wasi_fd_t,
old_flags: __wasi_lookupflags_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_open(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
dirflags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
oflags: __wasi_oflags_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inherting: __wasi_rights_t,
fdflags: __wasi_fdflags_t,
opened_fd: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_readlink(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t,
buf_len: size_t,
bufused: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_remove_directory(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_rename(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_symlink(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
old_path_ptr: uintptr_t,
old_path_len: size_t,
fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_path_unlink_file(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_poll_oneoff(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
r#in: uintptr_t,
out: uintptr_t,
nsubscriptions: size_t,
nevents: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_proc_exit(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
rval: __wasi_exitcode_t
)
#[no_mangle] +pub unsafe fn wasi_common_proc_raise(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
sig: __wasi_signal_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_random_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
buf: uintptr_t,
buf_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_sched_yield(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_sock_recv(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
ri_data_ptr: uintptr_t,
ri_data_len: size_t,
ri_flags: __wasi_riflags_t,
ro_datalen: uintptr_t,
ro_flags: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_sock_send(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
si_data_ptr: uintptr_t,
si_data_len: size_t,
si_flags: __wasi_siflags_t,
so_datalen: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn wasi_common_sock_shutdown(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
how: __wasi_sdflags_t
) -> __wasi_errno_t
| fs | A very experimental module modeled providing a high-level and safe
+filesystem interface, modeled after |
| hostcalls | |
| old | |
| wasi | Types and constants shared between 32-bit and 64-bit wasi. Types involving
+pointer or |
| wasi32 | Types and constants specific to 32-bit wasi. These are similar to the types
+in the |
| WasiCtx | |
| WasiCtxBuilder | A builder allowing customizable construction of |
| Error |
| preopen_dir |
| snapshot_0 |
Redirecting to ../../../../wasi_common/old/snapshot_0/struct.WasiCtx.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/old/snapshot_0/ctx/struct.WasiCtxBuilder.html b/api/wasi_common/old/snapshot_0/ctx/struct.WasiCtxBuilder.html new file mode 100644 index 000000000000..eb5e49b88af2 --- /dev/null +++ b/api/wasi_common/old/snapshot_0/ctx/struct.WasiCtxBuilder.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasi_common/old/snapshot_0/struct.WasiCtxBuilder.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/old/snapshot_0/hostcalls/fn.args_get.html b/api/wasi_common/old/snapshot_0/hostcalls/fn.args_get.html new file mode 100644 index 000000000000..7bd7b0a3736b --- /dev/null +++ b/api/wasi_common/old/snapshot_0/hostcalls/fn.args_get.html @@ -0,0 +1 @@ +pub unsafe fn args_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argv: uintptr_t,
argv_buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn args_sizes_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
pub unsafe fn clock_res_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
id: __wasi_clockid_t,
resolution: uintptr_t
) -> __wasi_errno_t
pub unsafe fn clock_time_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
id: __wasi_clockid_t,
precision: __wasi_timestamp_t,
time: uintptr_t
) -> __wasi_errno_t
pub unsafe fn environ_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
environ: uintptr_t,
environ_buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn environ_sizes_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_advise(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t,
advice: __wasi_advice_t
) -> __wasi_errno_t
pub unsafe fn fd_allocate(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t
) -> __wasi_errno_t
pub unsafe fn fd_close(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_datasync(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
stat: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_set_flags(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_fdflags_t
) -> __wasi_errno_t
pub unsafe fn fd_fdstat_set_rights(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inheriting: __wasi_rights_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_set_size(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
size: __wasi_filesize_t
) -> __wasi_errno_t
pub unsafe fn fd_filestat_set_times(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
pub unsafe fn fd_pread(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nread: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_prestat_dir_name(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn fd_prestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_pwrite(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nwritten: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_read(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nread: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_readdir(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
buf: uintptr_t,
buf_len: size_t,
cookie: __wasi_dircookie_t,
bufused: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_renumber(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
to: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_seek(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: __wasi_filedelta_t,
whence: __wasi_whence_t,
newoffset: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_sync(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t
) -> __wasi_errno_t
pub unsafe fn fd_tell(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
offset: uintptr_t
) -> __wasi_errno_t
pub unsafe fn fd_write(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nwritten: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_args_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argv: uintptr_t,
argv_buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_args_sizes_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_clock_res_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
id: __wasi_clockid_t,
resolution: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_clock_time_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
id: __wasi_clockid_t,
precision: __wasi_timestamp_t,
time: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_environ_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
environ: uintptr_t,
environ_buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_environ_sizes_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
argc: uintptr_t,
argv_buf_size: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_advise(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t,
advice: __wasi_advice_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_allocate(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filesize_t,
len: __wasi_filesize_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_close(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_datasync(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_fdstat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
stat: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_fdstat_set_flags(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_fdflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_fdstat_set_rights(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inheriting: __wasi_rights_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_filestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_filestat_set_size(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
size: __wasi_filesize_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_filestat_set_times(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_pread(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nread: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_prestat_dir_name(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_prestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_pwrite(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
offset: __wasi_filesize_t,
nwritten: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_read(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nread: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_readdir(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
buf: uintptr_t,
buf_len: size_t,
cookie: __wasi_dircookie_t,
bufused: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_renumber(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
to: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_seek(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: __wasi_filedelta_t,
whence: __wasi_whence_t,
newoffset: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_sync(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_tell(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
offset: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_fd_write(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
iovs_ptr: uintptr_t,
iovs_len: size_t,
nwritten: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_create_directory(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_filestat_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_filestat_set_times(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_link(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
old_fd: __wasi_fd_t,
old_flags: __wasi_lookupflags_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_open(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
dirflags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
oflags: __wasi_oflags_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inherting: __wasi_rights_t,
fdflags: __wasi_fdflags_t,
opened_fd: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_readlink(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t,
buf_len: size_t,
bufused: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_remove_directory(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_rename(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_symlink(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
old_path_ptr: uintptr_t,
old_path_len: size_t,
fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_path_unlink_file(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_poll_oneoff(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
r#in: uintptr_t,
out: uintptr_t,
nsubscriptions: size_t,
nevents: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_proc_exit(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
rval: __wasi_exitcode_t
)
#[no_mangle] +pub unsafe fn old_wasi_common_proc_raise(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
sig: __wasi_signal_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_random_get(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
buf: uintptr_t,
buf_len: size_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_sched_yield(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_sock_recv(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
ri_data_ptr: uintptr_t,
ri_data_len: size_t,
ri_flags: __wasi_riflags_t,
ro_datalen: uintptr_t,
ro_flags: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_sock_send(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
si_data_ptr: uintptr_t,
si_data_len: size_t,
si_flags: __wasi_siflags_t,
so_datalen: uintptr_t
) -> __wasi_errno_t
#[no_mangle] +pub unsafe fn old_wasi_common_sock_shutdown(
wasi_ctx: *mut WasiCtx,
memory: *mut u8,
memory_len: usize,
fd: __wasi_fd_t,
how: __wasi_sdflags_t
) -> __wasi_errno_t
pub unsafe fn path_create_directory(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_filestat_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_filestat_set_times(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
flags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
atim: __wasi_timestamp_t,
mtim: __wasi_timestamp_t,
fst_flags: __wasi_fstflags_t
) -> __wasi_errno_t
pub unsafe fn path_link(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
old_fd: __wasi_fd_t,
old_flags: __wasi_lookupflags_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_open(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
dirflags: __wasi_lookupflags_t,
path_ptr: uintptr_t,
path_len: size_t,
oflags: __wasi_oflags_t,
fs_rights_base: __wasi_rights_t,
fs_rights_inherting: __wasi_rights_t,
fdflags: __wasi_fdflags_t,
opened_fd: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_readlink(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t,
buf: uintptr_t,
buf_len: size_t,
bufused: uintptr_t
) -> __wasi_errno_t
pub unsafe fn path_remove_directory(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_rename(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
old_path_ptr: uintptr_t,
old_path_len: size_t,
new_fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_symlink(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
old_path_ptr: uintptr_t,
old_path_len: size_t,
fd: __wasi_fd_t,
new_path_ptr: uintptr_t,
new_path_len: size_t
) -> __wasi_errno_t
pub unsafe fn path_unlink_file(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
path_ptr: uintptr_t,
path_len: size_t
) -> __wasi_errno_t
pub unsafe fn poll_oneoff(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
r#in: uintptr_t,
out: uintptr_t,
nsubscriptions: size_t,
nevents: uintptr_t
) -> __wasi_errno_t
pub unsafe fn proc_exit(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
rval: __wasi_exitcode_t
)
pub unsafe fn proc_raise(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
sig: __wasi_signal_t
) -> __wasi_errno_t
pub unsafe fn random_get(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
buf: uintptr_t,
buf_len: size_t
) -> __wasi_errno_t
pub unsafe fn sched_yield(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8]
) -> __wasi_errno_t
pub unsafe fn sock_recv(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
ri_data_ptr: uintptr_t,
ri_data_len: size_t,
ri_flags: __wasi_riflags_t,
ro_datalen: uintptr_t,
ro_flags: uintptr_t
) -> __wasi_errno_t
pub unsafe fn sock_send(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
si_data_ptr: uintptr_t,
si_data_len: size_t,
si_flags: __wasi_siflags_t,
so_datalen: uintptr_t
) -> __wasi_errno_t
pub unsafe fn sock_shutdown(
wasi_ctx: &mut WasiCtx,
memory: &mut [u8],
fd: __wasi_fd_t,
how: __wasi_sdflags_t
) -> __wasi_errno_t
| hostcalls | |
| wasi | Types and constants shared between 32-bit and 64-bit wasi. Types involving
+pointer or |
| wasi32 | Types and constants specific to 32-bit wasi. These are similar to the types
+in the |
| WasiCtx | |
| WasiCtxBuilder | A builder allowing customizable construction of |
| Error | |
| Result |
impl WasiCtx[src]pub fn new<S: AsRef<[u8]>>(args: impl IntoIterator<Item = S>) -> Result<Self>[src]Make a new WasiCtx with some default settings.
File descriptors 0, 1, and 2 inherit stdin, stdout, and stderr from the host process.
+Environment variables are inherited from the host process.
+To override these behaviors, use WasiCtxBuilder.
impl RefUnwindSafe for WasiCtximpl Send for WasiCtximpl Sync for WasiCtximpl Unpin for WasiCtximpl UnwindSafe for WasiCtximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A builder allowing customizable construction of WasiCtx instances.
impl WasiCtxBuilder[src]pub fn new() -> Self[src]Builder for a new WasiCtx.
pub fn args<S: AsRef<[u8]>>(self, args: impl IntoIterator<Item = S>) -> Self[src]Add arguments to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn arg<S: AsRef<[u8]>>(self, arg: S) -> Self[src]Add an argument to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn inherit_args(self) -> Self[src]Inherit the command-line arguments from the host process.
+If any arguments from the host process contain invalid UTF-8, WasiCtxBuilder::build() will
+fail with Error::EILSEQ.
pub fn inherit_stdio(self) -> Self[src]Inherit the stdin, stdout, and stderr streams from the host process.
+pub fn inherit_env(self) -> Self[src]Inherit the environment variables from the host process.
+If any environment variables from the host process contain invalid Unicode (UTF-16 for
+Windows, UTF-8 for other platforms), WasiCtxBuilder::build() will fail with
+Error::EILSEQ.
pub fn env<S: AsRef<[u8]>>(self, k: S, v: S) -> Self[src]Add an entry to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn envs<S: AsRef<[u8]>, T: Borrow<(S, S)>>(
self,
envs: impl IntoIterator<Item = T>
) -> Self[src]Add entries to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn stdin(self, file: File) -> Self[src]Provide a File to use as stdin
+pub fn stdout(self, file: File) -> Self[src]Provide a File to use as stdout
+pub fn stderr(self, file: File) -> Self[src]Provide a File to use as stderr
+pub fn preopened_dir<P: AsRef<Path>>(self, dir: File, guest_path: P) -> Self[src]Add a preopened directory.
+pub fn build(self) -> Result<WasiCtx>[src]Build a WasiCtx, consuming this WasiCtxBuilder.
If any of the arguments or environment variables in this builder cannot be converted into
+CStrings, either due to NUL bytes or Unicode conversions, this returns Error::EILSEQ.
impl RefUnwindSafe for WasiCtxBuilderimpl Send for WasiCtxBuilderimpl Sync for WasiCtxBuilderimpl Unpin for WasiCtxBuilderimpl UnwindSafe for WasiCtxBuilderimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = Error;
type Result<T> = Result<T, Error>;
pub const __WASI_ADVICE_DONTNEED: __wasi_advice_t = 4;
pub const __WASI_ADVICE_NOREUSE: __wasi_advice_t = 5;
pub const __WASI_ADVICE_NORMAL: __wasi_advice_t = 0;
pub const __WASI_ADVICE_RANDOM: __wasi_advice_t = 2;
pub const __WASI_ADVICE_SEQUENTIAL: __wasi_advice_t = 1;
pub const __WASI_ADVICE_WILLNEED: __wasi_advice_t = 3;
pub const __WASI_CLOCKID_MONOTONIC: __wasi_clockid_t = 1;
pub const __WASI_CLOCKID_PROCESS_CPUTIME_ID: __wasi_clockid_t = 2;
pub const __WASI_CLOCKID_REALTIME: __wasi_clockid_t = 0;
pub const __WASI_CLOCKID_THREAD_CPUTIME_ID: __wasi_clockid_t = 3;
pub const __WASI_DIRCOOKIE_START: __wasi_dircookie_t = 0;
pub const __WASI_ERRNO_2BIG: __wasi_errno_t = 1;
pub const __WASI_ERRNO_ACCES: __wasi_errno_t = 2;
pub const __WASI_ERRNO_ADDRINUSE: __wasi_errno_t = 3;
pub const __WASI_ERRNO_ADDRNOTAVAIL: __wasi_errno_t = 4;
pub const __WASI_ERRNO_AFNOSUPPORT: __wasi_errno_t = 5;
pub const __WASI_ERRNO_AGAIN: __wasi_errno_t = 6;
pub const __WASI_ERRNO_ALREADY: __wasi_errno_t = 7;
pub const __WASI_ERRNO_BADF: __wasi_errno_t = 8;
pub const __WASI_ERRNO_BADMSG: __wasi_errno_t = 9;
pub const __WASI_ERRNO_BUSY: __wasi_errno_t = 10;
pub const __WASI_ERRNO_CANCELED: __wasi_errno_t = 11;
pub const __WASI_ERRNO_CHILD: __wasi_errno_t = 12;
pub const __WASI_ERRNO_CONNABORTED: __wasi_errno_t = 13;
pub const __WASI_ERRNO_CONNREFUSED: __wasi_errno_t = 14;
pub const __WASI_ERRNO_CONNRESET: __wasi_errno_t = 15;
pub const __WASI_ERRNO_DEADLK: __wasi_errno_t = 16;
pub const __WASI_ERRNO_DESTADDRREQ: __wasi_errno_t = 17;
pub const __WASI_ERRNO_DOM: __wasi_errno_t = 18;
pub const __WASI_ERRNO_DQUOT: __wasi_errno_t = 19;
pub const __WASI_ERRNO_EXIST: __wasi_errno_t = 20;
pub const __WASI_ERRNO_FAULT: __wasi_errno_t = 21;
pub const __WASI_ERRNO_FBIG: __wasi_errno_t = 22;
pub const __WASI_ERRNO_HOSTUNREACH: __wasi_errno_t = 23;
pub const __WASI_ERRNO_IDRM: __wasi_errno_t = 24;
pub const __WASI_ERRNO_ILSEQ: __wasi_errno_t = 25;
pub const __WASI_ERRNO_INPROGRESS: __wasi_errno_t = 26;
pub const __WASI_ERRNO_INTR: __wasi_errno_t = 27;
pub const __WASI_ERRNO_INVAL: __wasi_errno_t = 28;
pub const __WASI_ERRNO_IO: __wasi_errno_t = 29;
pub const __WASI_ERRNO_ISCONN: __wasi_errno_t = 30;
pub const __WASI_ERRNO_ISDIR: __wasi_errno_t = 31;
pub const __WASI_ERRNO_LOOP: __wasi_errno_t = 32;
pub const __WASI_ERRNO_MFILE: __wasi_errno_t = 33;
pub const __WASI_ERRNO_MLINK: __wasi_errno_t = 34;
pub const __WASI_ERRNO_MSGSIZE: __wasi_errno_t = 35;
pub const __WASI_ERRNO_MULTIHOP: __wasi_errno_t = 36;
pub const __WASI_ERRNO_NAMETOOLONG: __wasi_errno_t = 37;
pub const __WASI_ERRNO_NETDOWN: __wasi_errno_t = 38;
pub const __WASI_ERRNO_NETRESET: __wasi_errno_t = 39;
pub const __WASI_ERRNO_NETUNREACH: __wasi_errno_t = 40;
pub const __WASI_ERRNO_NFILE: __wasi_errno_t = 41;
pub const __WASI_ERRNO_NOBUFS: __wasi_errno_t = 42;
pub const __WASI_ERRNO_NODEV: __wasi_errno_t = 43;
pub const __WASI_ERRNO_NOENT: __wasi_errno_t = 44;
pub const __WASI_ERRNO_NOEXEC: __wasi_errno_t = 45;
pub const __WASI_ERRNO_NOLCK: __wasi_errno_t = 46;
pub const __WASI_ERRNO_NOLINK: __wasi_errno_t = 47;
pub const __WASI_ERRNO_NOMEM: __wasi_errno_t = 48;
pub const __WASI_ERRNO_NOMSG: __wasi_errno_t = 49;
pub const __WASI_ERRNO_NOPROTOOPT: __wasi_errno_t = 50;
pub const __WASI_ERRNO_NOSPC: __wasi_errno_t = 51;
pub const __WASI_ERRNO_NOSYS: __wasi_errno_t = 52;
pub const __WASI_ERRNO_NOTCAPABLE: __wasi_errno_t = 76;
pub const __WASI_ERRNO_NOTCONN: __wasi_errno_t = 53;
pub const __WASI_ERRNO_NOTDIR: __wasi_errno_t = 54;
pub const __WASI_ERRNO_NOTEMPTY: __wasi_errno_t = 55;
pub const __WASI_ERRNO_NOTRECOVERABLE: __wasi_errno_t = 56;
pub const __WASI_ERRNO_NOTSOCK: __wasi_errno_t = 57;
pub const __WASI_ERRNO_NOTSUP: __wasi_errno_t = 58;
pub const __WASI_ERRNO_NOTTY: __wasi_errno_t = 59;
pub const __WASI_ERRNO_NXIO: __wasi_errno_t = 60;
pub const __WASI_ERRNO_OVERFLOW: __wasi_errno_t = 61;
pub const __WASI_ERRNO_OWNERDEAD: __wasi_errno_t = 62;
pub const __WASI_ERRNO_PERM: __wasi_errno_t = 63;
pub const __WASI_ERRNO_PIPE: __wasi_errno_t = 64;
pub const __WASI_ERRNO_PROTO: __wasi_errno_t = 65;
pub const __WASI_ERRNO_PROTONOSUPPORT: __wasi_errno_t = 66;
pub const __WASI_ERRNO_PROTOTYPE: __wasi_errno_t = 67;
pub const __WASI_ERRNO_RANGE: __wasi_errno_t = 68;
pub const __WASI_ERRNO_ROFS: __wasi_errno_t = 69;
pub const __WASI_ERRNO_SPIPE: __wasi_errno_t = 70;
pub const __WASI_ERRNO_SRCH: __wasi_errno_t = 71;
pub const __WASI_ERRNO_STALE: __wasi_errno_t = 72;
pub const __WASI_ERRNO_SUCCESS: __wasi_errno_t = 0;
pub const __WASI_ERRNO_TIMEDOUT: __wasi_errno_t = 73;
pub const __WASI_ERRNO_TXTBSY: __wasi_errno_t = 74;
pub const __WASI_ERRNO_XDEV: __wasi_errno_t = 75;
pub const __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP: __wasi_eventrwflags_t = 1;
pub const __WASI_EVENTTYPE_CLOCK: __wasi_eventtype_t = 0;
pub const __WASI_EVENTTYPE_FD_READ: __wasi_eventtype_t = 1;
pub const __WASI_EVENTTYPE_FD_WRITE: __wasi_eventtype_t = 2;
pub const __WASI_FDFLAGS_APPEND: __wasi_fdflags_t = 1;
pub const __WASI_FDFLAGS_DSYNC: __wasi_fdflags_t = 2;
pub const __WASI_FDFLAGS_NONBLOCK: __wasi_fdflags_t = 4;
pub const __WASI_FDFLAGS_RSYNC: __wasi_fdflags_t = 8;
pub const __WASI_FDFLAGS_SYNC: __wasi_fdflags_t = 16;
pub const __WASI_FILETYPE_BLOCK_DEVICE: __wasi_filetype_t = 1;
pub const __WASI_FILETYPE_CHARACTER_DEVICE: __wasi_filetype_t = 2;
pub const __WASI_FILETYPE_DIRECTORY: __wasi_filetype_t = 3;
pub const __WASI_FILETYPE_REGULAR_FILE: __wasi_filetype_t = 4;
pub const __WASI_FILETYPE_SOCKET_DGRAM: __wasi_filetype_t = 5;
pub const __WASI_FILETYPE_SOCKET_STREAM: __wasi_filetype_t = 6;
pub const __WASI_FILETYPE_SYMBOLIC_LINK: __wasi_filetype_t = 7;
pub const __WASI_FILETYPE_UNKNOWN: __wasi_filetype_t = 0;
pub const __WASI_FSTFLAGS_ATIM: __wasi_fstflags_t = 1;
pub const __WASI_FSTFLAGS_ATIM_NOW: __wasi_fstflags_t = 2;
pub const __WASI_FSTFLAGS_MTIM: __wasi_fstflags_t = 4;
pub const __WASI_FSTFLAGS_MTIM_NOW: __wasi_fstflags_t = 8;
pub const __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW: __wasi_lookupflags_t = 1;
pub const __WASI_OFLAGS_CREAT: __wasi_oflags_t = 1;
pub const __WASI_OFLAGS_DIRECTORY: __wasi_oflags_t = 2;
pub const __WASI_OFLAGS_EXCL: __wasi_oflags_t = 4;
pub const __WASI_OFLAGS_TRUNC: __wasi_oflags_t = 8;
pub const __WASI_PREOPENTYPE_DIR: __wasi_preopentype_t = 0;
pub const __WASI_RIFLAGS_RECV_PEEK: __wasi_riflags_t = 1;
pub const __WASI_RIFLAGS_RECV_WAITALL: __wasi_riflags_t = 2;
pub const __WASI_RIGHTS_FD_ADVISE: __wasi_rights_t = 128;
pub const __WASI_RIGHTS_FD_ALLOCATE: __wasi_rights_t = 256;
pub const __WASI_RIGHTS_FD_DATASYNC: __wasi_rights_t = 1;
pub const __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS: __wasi_rights_t = 8;
pub const __WASI_RIGHTS_FD_FILESTAT_GET: __wasi_rights_t = 2097152;
pub const __WASI_RIGHTS_FD_FILESTAT_SET_SIZE: __wasi_rights_t = 4194304;
pub const __WASI_RIGHTS_FD_FILESTAT_SET_TIMES: __wasi_rights_t = 8388608;
pub const __WASI_RIGHTS_FD_READ: __wasi_rights_t = 2;
pub const __WASI_RIGHTS_FD_READDIR: __wasi_rights_t = 16384;
pub const __WASI_RIGHTS_FD_SEEK: __wasi_rights_t = 4;
pub const __WASI_RIGHTS_FD_SYNC: __wasi_rights_t = 16;
pub const __WASI_RIGHTS_FD_TELL: __wasi_rights_t = 32;
pub const __WASI_RIGHTS_FD_WRITE: __wasi_rights_t = 64;
pub const __WASI_RIGHTS_PATH_CREATE_DIRECTORY: __wasi_rights_t = 512;
pub const __WASI_RIGHTS_PATH_CREATE_FILE: __wasi_rights_t = 1024;
pub const __WASI_RIGHTS_PATH_FILESTAT_GET: __wasi_rights_t = 262144;
pub const __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE: __wasi_rights_t = 524288;
pub const __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES: __wasi_rights_t = 1048576;
pub const __WASI_RIGHTS_PATH_LINK_SOURCE: __wasi_rights_t = 2048;
pub const __WASI_RIGHTS_PATH_LINK_TARGET: __wasi_rights_t = 4096;
pub const __WASI_RIGHTS_PATH_OPEN: __wasi_rights_t = 8192;
pub const __WASI_RIGHTS_PATH_READLINK: __wasi_rights_t = 32768;
pub const __WASI_RIGHTS_PATH_REMOVE_DIRECTORY: __wasi_rights_t = 33554432;
pub const __WASI_RIGHTS_PATH_RENAME_SOURCE: __wasi_rights_t = 65536;
pub const __WASI_RIGHTS_PATH_RENAME_TARGET: __wasi_rights_t = 131072;
pub const __WASI_RIGHTS_PATH_SYMLINK: __wasi_rights_t = 16777216;
pub const __WASI_RIGHTS_PATH_UNLINK_FILE: __wasi_rights_t = 67108864;
pub const __WASI_RIGHTS_POLL_FD_READWRITE: __wasi_rights_t = 134217728;
pub const __WASI_RIGHTS_SOCK_SHUTDOWN: __wasi_rights_t = 268435456;
pub const __WASI_ROFLAGS_RECV_DATA_TRUNCATED: __wasi_roflags_t = 1;
pub const __WASI_SDFLAGS_RD: __wasi_sdflags_t = 1;
pub const __WASI_SDFLAGS_WR: __wasi_sdflags_t = 2;
pub const __WASI_SIGNAL_ABRT: __wasi_signal_t = 6;
pub const __WASI_SIGNAL_ALRM: __wasi_signal_t = 14;
pub const __WASI_SIGNAL_BUS: __wasi_signal_t = 7;
pub const __WASI_SIGNAL_CHLD: __wasi_signal_t = 16;
pub const __WASI_SIGNAL_CONT: __wasi_signal_t = 17;
pub const __WASI_SIGNAL_FPE: __wasi_signal_t = 8;
pub const __WASI_SIGNAL_HUP: __wasi_signal_t = 1;
pub const __WASI_SIGNAL_ILL: __wasi_signal_t = 4;
pub const __WASI_SIGNAL_INT: __wasi_signal_t = 2;
pub const __WASI_SIGNAL_KILL: __wasi_signal_t = 9;
pub const __WASI_SIGNAL_NONE: __wasi_signal_t = 0;
pub const __WASI_SIGNAL_PIPE: __wasi_signal_t = 13;
pub const __WASI_SIGNAL_POLL: __wasi_signal_t = 28;
pub const __WASI_SIGNAL_PROF: __wasi_signal_t = 26;
pub const __WASI_SIGNAL_PWR: __wasi_signal_t = 29;
pub const __WASI_SIGNAL_QUIT: __wasi_signal_t = 3;
pub const __WASI_SIGNAL_SEGV: __wasi_signal_t = 11;
pub const __WASI_SIGNAL_STOP: __wasi_signal_t = 18;
pub const __WASI_SIGNAL_SYS: __wasi_signal_t = 30;
pub const __WASI_SIGNAL_TERM: __wasi_signal_t = 15;
pub const __WASI_SIGNAL_TRAP: __wasi_signal_t = 5;
pub const __WASI_SIGNAL_TSTP: __wasi_signal_t = 19;
pub const __WASI_SIGNAL_TTIN: __wasi_signal_t = 20;
pub const __WASI_SIGNAL_TTOU: __wasi_signal_t = 21;
pub const __WASI_SIGNAL_URG: __wasi_signal_t = 22;
pub const __WASI_SIGNAL_USR1: __wasi_signal_t = 10;
pub const __WASI_SIGNAL_USR2: __wasi_signal_t = 12;
pub const __WASI_SIGNAL_VTALRM: __wasi_signal_t = 25;
pub const __WASI_SIGNAL_WINCH: __wasi_signal_t = 27;
pub const __WASI_SIGNAL_XCPU: __wasi_signal_t = 23;
pub const __WASI_SIGNAL_XFSZ: __wasi_signal_t = 24;
pub const __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME: __wasi_subclockflags_t = 1;
pub const __WASI_WHENCE_CUR: __wasi_whence_t = 0;
pub const __WASI_WHENCE_END: __wasi_whence_t = 1;
pub const __WASI_WHENCE_SET: __wasi_whence_t = 2;
pub fn strerror(errno: __wasi_errno_t) -> &'static str
pub fn whence_to_str(whence: __wasi_whence_t) -> &'static str
Types and constants shared between 32-bit and 64-bit wasi. Types involving
+pointer or usize-sized data are excluded here, so this file only contains
+fixed-size types, so it's host/target independent.
| __wasi_dirent_t | |
| __wasi_event_fd_readwrite_t | |
| __wasi_event_t | |
| __wasi_fdstat_t | |
| __wasi_filestat_t | |
| __wasi_subscription_clock_t | |
| __wasi_subscription_fd_readwrite_t | |
| __wasi_subscription_t |
| strerror | |
| whence_to_str |
| __wasi_event_u_t | |
| __wasi_subscription_u_t |
d_next: __wasi_dircookie_td_ino: __wasi_inode_td_namlen: __wasi_dirnamlen_td_type: __wasi_filetype_timpl Clone for __wasi_dirent_t[src]fn clone(&self) -> __wasi_dirent_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_dirent_t[src]impl Debug for __wasi_dirent_t[src]impl Eq for __wasi_dirent_t[src]impl Hash for __wasi_dirent_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_dirent_t> for __wasi_dirent_t[src]fn eq(&self, other: &__wasi_dirent_t) -> bool[src]fn ne(&self, other: &__wasi_dirent_t) -> bool[src]impl StructuralEq for __wasi_dirent_t[src]impl StructuralPartialEq for __wasi_dirent_t[src]impl RefUnwindSafe for __wasi_dirent_timpl Send for __wasi_dirent_timpl Sync for __wasi_dirent_timpl Unpin for __wasi_dirent_timpl UnwindSafe for __wasi_dirent_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]nbytes: __wasi_filesize_tflags: __wasi_eventrwflags_timpl Clone for __wasi_event_fd_readwrite_t[src]fn clone(&self) -> __wasi_event_fd_readwrite_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_fd_readwrite_t[src]impl Debug for __wasi_event_fd_readwrite_t[src]impl Eq for __wasi_event_fd_readwrite_t[src]impl Hash for __wasi_event_fd_readwrite_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_event_fd_readwrite_t> for __wasi_event_fd_readwrite_t[src]fn eq(&self, other: &__wasi_event_fd_readwrite_t) -> bool[src]fn ne(&self, other: &__wasi_event_fd_readwrite_t) -> bool[src]impl StructuralEq for __wasi_event_fd_readwrite_t[src]impl StructuralPartialEq for __wasi_event_fd_readwrite_t[src]impl RefUnwindSafe for __wasi_event_fd_readwrite_timpl Send for __wasi_event_fd_readwrite_timpl Sync for __wasi_event_fd_readwrite_timpl Unpin for __wasi_event_fd_readwrite_timpl UnwindSafe for __wasi_event_fd_readwrite_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]userdata: __wasi_userdata_terror: __wasi_errno_ttype: __wasi_eventtype_tu: __wasi_event_u_timpl Clone for __wasi_event_t[src]fn clone(&self) -> __wasi_event_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_t[src]impl RefUnwindSafe for __wasi_event_timpl Send for __wasi_event_timpl Sync for __wasi_event_timpl Unpin for __wasi_event_timpl UnwindSafe for __wasi_event_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]fs_filetype: __wasi_filetype_tfs_flags: __wasi_fdflags_tfs_rights_base: __wasi_rights_tfs_rights_inheriting: __wasi_rights_timpl Clone for __wasi_fdstat_t[src]fn clone(&self) -> __wasi_fdstat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_fdstat_t[src]impl Debug for __wasi_fdstat_t[src]impl Eq for __wasi_fdstat_t[src]impl Hash for __wasi_fdstat_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_fdstat_t> for __wasi_fdstat_t[src]fn eq(&self, other: &__wasi_fdstat_t) -> bool[src]fn ne(&self, other: &__wasi_fdstat_t) -> bool[src]impl StructuralEq for __wasi_fdstat_t[src]impl StructuralPartialEq for __wasi_fdstat_t[src]impl RefUnwindSafe for __wasi_fdstat_timpl Send for __wasi_fdstat_timpl Sync for __wasi_fdstat_timpl Unpin for __wasi_fdstat_timpl UnwindSafe for __wasi_fdstat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]dev: __wasi_device_tino: __wasi_inode_tfiletype: __wasi_filetype_tnlink: __wasi_linkcount_tsize: __wasi_filesize_tatim: __wasi_timestamp_tmtim: __wasi_timestamp_tctim: __wasi_timestamp_timpl Clone for __wasi_filestat_t[src]fn clone(&self) -> __wasi_filestat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_filestat_t[src]impl Debug for __wasi_filestat_t[src]impl Eq for __wasi_filestat_t[src]impl Hash for __wasi_filestat_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_filestat_t> for __wasi_filestat_t[src]fn eq(&self, other: &__wasi_filestat_t) -> bool[src]fn ne(&self, other: &__wasi_filestat_t) -> bool[src]impl StructuralEq for __wasi_filestat_t[src]impl StructuralPartialEq for __wasi_filestat_t[src]impl RefUnwindSafe for __wasi_filestat_timpl Send for __wasi_filestat_timpl Sync for __wasi_filestat_timpl Unpin for __wasi_filestat_timpl UnwindSafe for __wasi_filestat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]identifier: __wasi_userdata_tid: __wasi_clockid_ttimeout: __wasi_timestamp_tprecision: __wasi_timestamp_tflags: __wasi_subclockflags_timpl Clone for __wasi_subscription_clock_t[src]fn clone(&self) -> __wasi_subscription_clock_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_clock_t[src]impl Debug for __wasi_subscription_clock_t[src]impl Eq for __wasi_subscription_clock_t[src]impl Hash for __wasi_subscription_clock_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_subscription_clock_t> for __wasi_subscription_clock_t[src]fn eq(&self, other: &__wasi_subscription_clock_t) -> bool[src]fn ne(&self, other: &__wasi_subscription_clock_t) -> bool[src]impl StructuralEq for __wasi_subscription_clock_t[src]impl StructuralPartialEq for __wasi_subscription_clock_t[src]impl RefUnwindSafe for __wasi_subscription_clock_timpl Send for __wasi_subscription_clock_timpl Sync for __wasi_subscription_clock_timpl Unpin for __wasi_subscription_clock_timpl UnwindSafe for __wasi_subscription_clock_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]file_descriptor: __wasi_fd_timpl Clone for __wasi_subscription_fd_readwrite_t[src]fn clone(&self) -> __wasi_subscription_fd_readwrite_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_fd_readwrite_t[src]impl Debug for __wasi_subscription_fd_readwrite_t[src]impl Eq for __wasi_subscription_fd_readwrite_t[src]impl Hash for __wasi_subscription_fd_readwrite_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_subscription_fd_readwrite_t> for __wasi_subscription_fd_readwrite_t[src]fn eq(&self, other: &__wasi_subscription_fd_readwrite_t) -> bool[src]fn ne(&self, other: &__wasi_subscription_fd_readwrite_t) -> bool[src]impl StructuralEq for __wasi_subscription_fd_readwrite_t[src]impl StructuralPartialEq for __wasi_subscription_fd_readwrite_t[src]impl RefUnwindSafe for __wasi_subscription_fd_readwrite_timpl Send for __wasi_subscription_fd_readwrite_timpl Sync for __wasi_subscription_fd_readwrite_timpl Unpin for __wasi_subscription_fd_readwrite_timpl UnwindSafe for __wasi_subscription_fd_readwrite_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]userdata: __wasi_userdata_ttype: __wasi_eventtype_tu: __wasi_subscription_u_timpl Clone for __wasi_subscription_t[src]fn clone(&self) -> __wasi_subscription_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_t[src]impl RefUnwindSafe for __wasi_subscription_timpl Send for __wasi_subscription_timpl Sync for __wasi_subscription_timpl Unpin for __wasi_subscription_timpl UnwindSafe for __wasi_subscription_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type __wasi_advice_t = u8;
type __wasi_clockid_t = u32;
type __wasi_device_t = u64;
type __wasi_dircookie_t = u64;
type __wasi_dirnamlen_t = u32;
type __wasi_errno_t = u16;
type __wasi_eventrwflags_t = u16;
type __wasi_eventtype_t = u8;
type __wasi_exitcode_t = u32;
type __wasi_fd_t = u32;
type __wasi_fdflags_t = u16;
type __wasi_filedelta_t = i64;
type __wasi_filesize_t = u64;
type __wasi_filetype_t = u8;
type __wasi_fstflags_t = u16;
type __wasi_inode_t = u64;
type __wasi_linkcount_t = u32;
type __wasi_lookupflags_t = u32;
type __wasi_oflags_t = u16;
type __wasi_preopentype_t = u8;
type __wasi_riflags_t = u16;
type __wasi_rights_t = u64;
type __wasi_roflags_t = u16;
type __wasi_sdflags_t = u8;
type __wasi_siflags_t = u16;
type __wasi_signal_t = u8;
type __wasi_subclockflags_t = u16;
type __wasi_timestamp_t = u64;
type __wasi_userdata_t = u64;
type __wasi_whence_t = u8;
fd_readwrite: __wasi_event_fd_readwrite_timpl Clone for __wasi_event_u_t[src]fn clone(&self) -> __wasi_event_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_u_t[src]impl RefUnwindSafe for __wasi_event_u_timpl Send for __wasi_event_u_timpl Sync for __wasi_event_u_timpl Unpin for __wasi_event_u_timpl UnwindSafe for __wasi_event_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]clock: __wasi_subscription_clock_tfd_readwrite: __wasi_subscription_fd_readwrite_timpl Clone for __wasi_subscription_u_t[src]fn clone(&self) -> __wasi_subscription_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_u_t[src]impl RefUnwindSafe for __wasi_subscription_u_timpl Send for __wasi_subscription_u_timpl Sync for __wasi_subscription_u_timpl Unpin for __wasi_subscription_u_timpl UnwindSafe for __wasi_subscription_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Types and constants specific to 32-bit wasi. These are similar to the types
+in the host module, but pointers and usize values are replaced with
+u32-sized types.
| __wasi_ciovec_t | |
| __wasi_iovec_t | |
| __wasi_prestat_dir_t | |
| __wasi_prestat_t |
| __wasi_ciovec_array_t | |
| __wasi_iovec_array_t | |
| __wasi_size_t | |
| size_t | |
| uintptr_t |
| __wasi_prestat_u_t |
buf: u32buf_len: __wasi_size_timpl Clone for __wasi_ciovec_t[src]fn clone(&self) -> __wasi_ciovec_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_ciovec_t[src]impl Debug for __wasi_ciovec_t[src]impl Eq for __wasi_ciovec_t[src]impl Hash for __wasi_ciovec_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_ciovec_t> for __wasi_ciovec_t[src]fn eq(&self, other: &__wasi_ciovec_t) -> bool[src]fn ne(&self, other: &__wasi_ciovec_t) -> bool[src]impl StructuralEq for __wasi_ciovec_t[src]impl StructuralPartialEq for __wasi_ciovec_t[src]impl RefUnwindSafe for __wasi_ciovec_timpl Send for __wasi_ciovec_timpl Sync for __wasi_ciovec_timpl Unpin for __wasi_ciovec_timpl UnwindSafe for __wasi_ciovec_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]buf: u32buf_len: __wasi_size_timpl Clone for __wasi_iovec_t[src]fn clone(&self) -> __wasi_iovec_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_iovec_t[src]impl Debug for __wasi_iovec_t[src]impl Eq for __wasi_iovec_t[src]impl Hash for __wasi_iovec_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_iovec_t> for __wasi_iovec_t[src]fn eq(&self, other: &__wasi_iovec_t) -> bool[src]fn ne(&self, other: &__wasi_iovec_t) -> bool[src]impl StructuralEq for __wasi_iovec_t[src]impl StructuralPartialEq for __wasi_iovec_t[src]impl RefUnwindSafe for __wasi_iovec_timpl Send for __wasi_iovec_timpl Sync for __wasi_iovec_timpl Unpin for __wasi_iovec_timpl UnwindSafe for __wasi_iovec_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pr_name_len: __wasi_size_timpl Clone for __wasi_prestat_dir_t[src]fn clone(&self) -> __wasi_prestat_dir_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_dir_t[src]impl Debug for __wasi_prestat_dir_t[src]impl Eq for __wasi_prestat_dir_t[src]impl Hash for __wasi_prestat_dir_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_prestat_dir_t> for __wasi_prestat_dir_t[src]fn eq(&self, other: &__wasi_prestat_dir_t) -> bool[src]fn ne(&self, other: &__wasi_prestat_dir_t) -> bool[src]impl StructuralEq for __wasi_prestat_dir_t[src]impl StructuralPartialEq for __wasi_prestat_dir_t[src]impl RefUnwindSafe for __wasi_prestat_dir_timpl Send for __wasi_prestat_dir_timpl Sync for __wasi_prestat_dir_timpl Unpin for __wasi_prestat_dir_timpl UnwindSafe for __wasi_prestat_dir_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pr_type: __wasi_preopentype_tu: __wasi_prestat_u_timpl Clone for __wasi_prestat_t[src]fn clone(&self) -> __wasi_prestat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_t[src]impl RefUnwindSafe for __wasi_prestat_timpl Send for __wasi_prestat_timpl Sync for __wasi_prestat_timpl Unpin for __wasi_prestat_timpl UnwindSafe for __wasi_prestat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type __wasi_ciovec_array_t = (u32, u32);
type __wasi_iovec_array_t = (u32, u32);
type __wasi_size_t = u32;
type size_t = u32;
type uintptr_t = u32;
dir: __wasi_prestat_dir_timpl Clone for __wasi_prestat_u_t[src]fn clone(&self) -> __wasi_prestat_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_u_t[src]impl RefUnwindSafe for __wasi_prestat_u_timpl Send for __wasi_prestat_u_timpl Sync for __wasi_prestat_u_timpl Unpin for __wasi_prestat_u_timpl UnwindSafe for __wasi_prestat_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl WasiCtx[src]pub fn new<S: AsRef<[u8]>>(
args: impl IntoIterator<Item = S>
) -> Result<Self, Error>[src]Make a new WasiCtx with some default settings.
File descriptors 0, 1, and 2 inherit stdin, stdout, and stderr from the host process.
+Environment variables are inherited from the host process.
+To override these behaviors, use WasiCtxBuilder.
impl RefUnwindSafe for WasiCtximpl Send for WasiCtximpl Sync for WasiCtximpl Unpin for WasiCtximpl UnwindSafe for WasiCtximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A builder allowing customizable construction of WasiCtx instances.
impl WasiCtxBuilder[src]pub fn new() -> Self[src]Builder for a new WasiCtx.
pub fn args<S: AsRef<[u8]>>(self, args: impl IntoIterator<Item = S>) -> Self[src]Add arguments to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn arg<S: AsRef<[u8]>>(self, arg: S) -> Self[src]Add an argument to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn inherit_args(self) -> Self[src]Inherit the command-line arguments from the host process.
+If any arguments from the host process contain invalid UTF-8, WasiCtxBuilder::build() will
+fail with Error::EILSEQ.
pub fn inherit_stdio(self) -> Self[src]Inherit the stdin, stdout, and stderr streams from the host process.
+pub fn inherit_env(self) -> Self[src]Inherit the environment variables from the host process.
+If any environment variables from the host process contain invalid Unicode (UTF-16 for
+Windows, UTF-8 for other platforms), WasiCtxBuilder::build() will fail with
+Error::EILSEQ.
pub fn env<S: AsRef<[u8]>>(self, k: S, v: S) -> Self[src]Add an entry to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn envs<S: AsRef<[u8]>, T: Borrow<(S, S)>>(
self,
envs: impl IntoIterator<Item = T>
) -> Self[src]Add entries to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn stdin(self, file: File) -> Self[src]Provide a File to use as stdin
+pub fn stdout(self, file: File) -> Self[src]Provide a File to use as stdout
+pub fn stderr(self, file: File) -> Self[src]Provide a File to use as stderr
+pub fn preopened_dir<P: AsRef<Path>>(self, dir: File, guest_path: P) -> Self[src]Add a preopened directory.
+pub fn build(self) -> Result<WasiCtx, Error>[src]Build a WasiCtx, consuming this WasiCtxBuilder.
If any of the arguments or environment variables in this builder cannot be converted into
+CStrings, either due to NUL bytes or Unicode conversions, this returns Error::EILSEQ.
impl RefUnwindSafe for WasiCtxBuilderimpl Send for WasiCtxBuilderimpl Sync for WasiCtxBuilderimpl Unpin for WasiCtxBuilderimpl UnwindSafe for WasiCtxBuilderimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../../wasi_common/fn.preopen_dir.html...
+ + + \ No newline at end of file diff --git a/api/wasi_common/wasi/constant.__WASI_ADVICE_DONTNEED.html b/api/wasi_common/wasi/constant.__WASI_ADVICE_DONTNEED.html new file mode 100644 index 000000000000..659b6e7d6da1 --- /dev/null +++ b/api/wasi_common/wasi/constant.__WASI_ADVICE_DONTNEED.html @@ -0,0 +1 @@ +pub const __WASI_ADVICE_DONTNEED: __wasi_advice_t = 4;
pub const __WASI_ADVICE_NOREUSE: __wasi_advice_t = 5;
pub const __WASI_ADVICE_NORMAL: __wasi_advice_t = 0;
pub const __WASI_ADVICE_RANDOM: __wasi_advice_t = 2;
pub const __WASI_ADVICE_SEQUENTIAL: __wasi_advice_t = 1;
pub const __WASI_ADVICE_WILLNEED: __wasi_advice_t = 3;
pub const __WASI_CLOCKID_MONOTONIC: __wasi_clockid_t = 1;
pub const __WASI_CLOCKID_PROCESS_CPUTIME_ID: __wasi_clockid_t = 2;
pub const __WASI_CLOCKID_REALTIME: __wasi_clockid_t = 0;
pub const __WASI_CLOCKID_THREAD_CPUTIME_ID: __wasi_clockid_t = 3;
pub const __WASI_DIRCOOKIE_START: __wasi_dircookie_t = 0;
pub const __WASI_ERRNO_2BIG: __wasi_errno_t = 1;
pub const __WASI_ERRNO_ACCES: __wasi_errno_t = 2;
pub const __WASI_ERRNO_ADDRINUSE: __wasi_errno_t = 3;
pub const __WASI_ERRNO_ADDRNOTAVAIL: __wasi_errno_t = 4;
pub const __WASI_ERRNO_AFNOSUPPORT: __wasi_errno_t = 5;
pub const __WASI_ERRNO_AGAIN: __wasi_errno_t = 6;
pub const __WASI_ERRNO_ALREADY: __wasi_errno_t = 7;
pub const __WASI_ERRNO_BADF: __wasi_errno_t = 8;
pub const __WASI_ERRNO_BADMSG: __wasi_errno_t = 9;
pub const __WASI_ERRNO_BUSY: __wasi_errno_t = 10;
pub const __WASI_ERRNO_CANCELED: __wasi_errno_t = 11;
pub const __WASI_ERRNO_CHILD: __wasi_errno_t = 12;
pub const __WASI_ERRNO_CONNABORTED: __wasi_errno_t = 13;
pub const __WASI_ERRNO_CONNREFUSED: __wasi_errno_t = 14;
pub const __WASI_ERRNO_CONNRESET: __wasi_errno_t = 15;
pub const __WASI_ERRNO_DEADLK: __wasi_errno_t = 16;
pub const __WASI_ERRNO_DESTADDRREQ: __wasi_errno_t = 17;
pub const __WASI_ERRNO_DOM: __wasi_errno_t = 18;
pub const __WASI_ERRNO_DQUOT: __wasi_errno_t = 19;
pub const __WASI_ERRNO_EXIST: __wasi_errno_t = 20;
pub const __WASI_ERRNO_FAULT: __wasi_errno_t = 21;
pub const __WASI_ERRNO_FBIG: __wasi_errno_t = 22;
pub const __WASI_ERRNO_HOSTUNREACH: __wasi_errno_t = 23;
pub const __WASI_ERRNO_IDRM: __wasi_errno_t = 24;
pub const __WASI_ERRNO_ILSEQ: __wasi_errno_t = 25;
pub const __WASI_ERRNO_INPROGRESS: __wasi_errno_t = 26;
pub const __WASI_ERRNO_INTR: __wasi_errno_t = 27;
pub const __WASI_ERRNO_INVAL: __wasi_errno_t = 28;
pub const __WASI_ERRNO_IO: __wasi_errno_t = 29;
pub const __WASI_ERRNO_ISCONN: __wasi_errno_t = 30;
pub const __WASI_ERRNO_ISDIR: __wasi_errno_t = 31;
pub const __WASI_ERRNO_LOOP: __wasi_errno_t = 32;
pub const __WASI_ERRNO_MFILE: __wasi_errno_t = 33;
pub const __WASI_ERRNO_MLINK: __wasi_errno_t = 34;
pub const __WASI_ERRNO_MSGSIZE: __wasi_errno_t = 35;
pub const __WASI_ERRNO_MULTIHOP: __wasi_errno_t = 36;
pub const __WASI_ERRNO_NAMETOOLONG: __wasi_errno_t = 37;
pub const __WASI_ERRNO_NETDOWN: __wasi_errno_t = 38;
pub const __WASI_ERRNO_NETRESET: __wasi_errno_t = 39;
pub const __WASI_ERRNO_NETUNREACH: __wasi_errno_t = 40;
pub const __WASI_ERRNO_NFILE: __wasi_errno_t = 41;
pub const __WASI_ERRNO_NOBUFS: __wasi_errno_t = 42;
pub const __WASI_ERRNO_NODEV: __wasi_errno_t = 43;
pub const __WASI_ERRNO_NOENT: __wasi_errno_t = 44;
pub const __WASI_ERRNO_NOEXEC: __wasi_errno_t = 45;
pub const __WASI_ERRNO_NOLCK: __wasi_errno_t = 46;
pub const __WASI_ERRNO_NOLINK: __wasi_errno_t = 47;
pub const __WASI_ERRNO_NOMEM: __wasi_errno_t = 48;
pub const __WASI_ERRNO_NOMSG: __wasi_errno_t = 49;
pub const __WASI_ERRNO_NOPROTOOPT: __wasi_errno_t = 50;
pub const __WASI_ERRNO_NOSPC: __wasi_errno_t = 51;
pub const __WASI_ERRNO_NOSYS: __wasi_errno_t = 52;
pub const __WASI_ERRNO_NOTCAPABLE: __wasi_errno_t = 76;
pub const __WASI_ERRNO_NOTCONN: __wasi_errno_t = 53;
pub const __WASI_ERRNO_NOTDIR: __wasi_errno_t = 54;
pub const __WASI_ERRNO_NOTEMPTY: __wasi_errno_t = 55;
pub const __WASI_ERRNO_NOTRECOVERABLE: __wasi_errno_t = 56;
pub const __WASI_ERRNO_NOTSOCK: __wasi_errno_t = 57;
pub const __WASI_ERRNO_NOTSUP: __wasi_errno_t = 58;
pub const __WASI_ERRNO_NOTTY: __wasi_errno_t = 59;
pub const __WASI_ERRNO_NXIO: __wasi_errno_t = 60;
pub const __WASI_ERRNO_OVERFLOW: __wasi_errno_t = 61;
pub const __WASI_ERRNO_OWNERDEAD: __wasi_errno_t = 62;
pub const __WASI_ERRNO_PERM: __wasi_errno_t = 63;
pub const __WASI_ERRNO_PIPE: __wasi_errno_t = 64;
pub const __WASI_ERRNO_PROTO: __wasi_errno_t = 65;
pub const __WASI_ERRNO_PROTONOSUPPORT: __wasi_errno_t = 66;
pub const __WASI_ERRNO_PROTOTYPE: __wasi_errno_t = 67;
pub const __WASI_ERRNO_RANGE: __wasi_errno_t = 68;
pub const __WASI_ERRNO_ROFS: __wasi_errno_t = 69;
pub const __WASI_ERRNO_SPIPE: __wasi_errno_t = 70;
pub const __WASI_ERRNO_SRCH: __wasi_errno_t = 71;
pub const __WASI_ERRNO_STALE: __wasi_errno_t = 72;
pub const __WASI_ERRNO_SUCCESS: __wasi_errno_t = 0;
pub const __WASI_ERRNO_TIMEDOUT: __wasi_errno_t = 73;
pub const __WASI_ERRNO_TXTBSY: __wasi_errno_t = 74;
pub const __WASI_ERRNO_XDEV: __wasi_errno_t = 75;
pub const __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP: __wasi_eventrwflags_t = 1;
pub const __WASI_EVENTTYPE_CLOCK: __wasi_eventtype_t = 0;
pub const __WASI_EVENTTYPE_FD_READ: __wasi_eventtype_t = 1;
pub const __WASI_EVENTTYPE_FD_WRITE: __wasi_eventtype_t = 2;
pub const __WASI_FDFLAGS_APPEND: __wasi_fdflags_t = 1;
pub const __WASI_FDFLAGS_DSYNC: __wasi_fdflags_t = 2;
pub const __WASI_FDFLAGS_NONBLOCK: __wasi_fdflags_t = 4;
pub const __WASI_FDFLAGS_RSYNC: __wasi_fdflags_t = 8;
pub const __WASI_FDFLAGS_SYNC: __wasi_fdflags_t = 16;
pub const __WASI_FILETYPE_BLOCK_DEVICE: __wasi_filetype_t = 1;
pub const __WASI_FILETYPE_CHARACTER_DEVICE: __wasi_filetype_t = 2;
pub const __WASI_FILETYPE_DIRECTORY: __wasi_filetype_t = 3;
pub const __WASI_FILETYPE_REGULAR_FILE: __wasi_filetype_t = 4;
pub const __WASI_FILETYPE_SOCKET_DGRAM: __wasi_filetype_t = 5;
pub const __WASI_FILETYPE_SOCKET_STREAM: __wasi_filetype_t = 6;
pub const __WASI_FILETYPE_SYMBOLIC_LINK: __wasi_filetype_t = 7;
pub const __WASI_FILETYPE_UNKNOWN: __wasi_filetype_t = 0;
pub const __WASI_FSTFLAGS_ATIM: __wasi_fstflags_t = 1;
pub const __WASI_FSTFLAGS_ATIM_NOW: __wasi_fstflags_t = 2;
pub const __WASI_FSTFLAGS_MTIM: __wasi_fstflags_t = 4;
pub const __WASI_FSTFLAGS_MTIM_NOW: __wasi_fstflags_t = 8;
pub const __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW: __wasi_lookupflags_t = 1;
pub const __WASI_OFLAGS_CREAT: __wasi_oflags_t = 1;
pub const __WASI_OFLAGS_DIRECTORY: __wasi_oflags_t = 2;
pub const __WASI_OFLAGS_EXCL: __wasi_oflags_t = 4;
pub const __WASI_OFLAGS_TRUNC: __wasi_oflags_t = 8;
pub const __WASI_PREOPENTYPE_DIR: __wasi_preopentype_t = 0;
pub const __WASI_RIFLAGS_RECV_PEEK: __wasi_riflags_t = 1;
pub const __WASI_RIFLAGS_RECV_WAITALL: __wasi_riflags_t = 2;
pub const __WASI_RIGHTS_FD_ADVISE: __wasi_rights_t = 128;
pub const __WASI_RIGHTS_FD_ALLOCATE: __wasi_rights_t = 256;
pub const __WASI_RIGHTS_FD_DATASYNC: __wasi_rights_t = 1;
pub const __WASI_RIGHTS_FD_FDSTAT_SET_FLAGS: __wasi_rights_t = 8;
pub const __WASI_RIGHTS_FD_FILESTAT_GET: __wasi_rights_t = 2097152;
pub const __WASI_RIGHTS_FD_FILESTAT_SET_SIZE: __wasi_rights_t = 4194304;
pub const __WASI_RIGHTS_FD_FILESTAT_SET_TIMES: __wasi_rights_t = 8388608;
pub const __WASI_RIGHTS_FD_READ: __wasi_rights_t = 2;
pub const __WASI_RIGHTS_FD_READDIR: __wasi_rights_t = 16384;
pub const __WASI_RIGHTS_FD_SEEK: __wasi_rights_t = 4;
pub const __WASI_RIGHTS_FD_SYNC: __wasi_rights_t = 16;
pub const __WASI_RIGHTS_FD_TELL: __wasi_rights_t = 32;
pub const __WASI_RIGHTS_FD_WRITE: __wasi_rights_t = 64;
pub const __WASI_RIGHTS_PATH_CREATE_DIRECTORY: __wasi_rights_t = 512;
pub const __WASI_RIGHTS_PATH_CREATE_FILE: __wasi_rights_t = 1024;
pub const __WASI_RIGHTS_PATH_FILESTAT_GET: __wasi_rights_t = 262144;
pub const __WASI_RIGHTS_PATH_FILESTAT_SET_SIZE: __wasi_rights_t = 524288;
pub const __WASI_RIGHTS_PATH_FILESTAT_SET_TIMES: __wasi_rights_t = 1048576;
pub const __WASI_RIGHTS_PATH_LINK_SOURCE: __wasi_rights_t = 2048;
pub const __WASI_RIGHTS_PATH_LINK_TARGET: __wasi_rights_t = 4096;
pub const __WASI_RIGHTS_PATH_OPEN: __wasi_rights_t = 8192;
pub const __WASI_RIGHTS_PATH_READLINK: __wasi_rights_t = 32768;
pub const __WASI_RIGHTS_PATH_REMOVE_DIRECTORY: __wasi_rights_t = 33554432;
pub const __WASI_RIGHTS_PATH_RENAME_SOURCE: __wasi_rights_t = 65536;
pub const __WASI_RIGHTS_PATH_RENAME_TARGET: __wasi_rights_t = 131072;
pub const __WASI_RIGHTS_PATH_SYMLINK: __wasi_rights_t = 16777216;
pub const __WASI_RIGHTS_PATH_UNLINK_FILE: __wasi_rights_t = 67108864;
pub const __WASI_RIGHTS_POLL_FD_READWRITE: __wasi_rights_t = 134217728;
pub const __WASI_RIGHTS_SOCK_SHUTDOWN: __wasi_rights_t = 268435456;
pub const __WASI_ROFLAGS_RECV_DATA_TRUNCATED: __wasi_roflags_t = 1;
pub const __WASI_SDFLAGS_RD: __wasi_sdflags_t = 1;
pub const __WASI_SDFLAGS_WR: __wasi_sdflags_t = 2;
pub const __WASI_SIGNAL_ABRT: __wasi_signal_t = 6;
pub const __WASI_SIGNAL_ALRM: __wasi_signal_t = 14;
pub const __WASI_SIGNAL_BUS: __wasi_signal_t = 7;
pub const __WASI_SIGNAL_CHLD: __wasi_signal_t = 16;
pub const __WASI_SIGNAL_CONT: __wasi_signal_t = 17;
pub const __WASI_SIGNAL_FPE: __wasi_signal_t = 8;
pub const __WASI_SIGNAL_HUP: __wasi_signal_t = 1;
pub const __WASI_SIGNAL_ILL: __wasi_signal_t = 4;
pub const __WASI_SIGNAL_INT: __wasi_signal_t = 2;
pub const __WASI_SIGNAL_KILL: __wasi_signal_t = 9;
pub const __WASI_SIGNAL_NONE: __wasi_signal_t = 0;
pub const __WASI_SIGNAL_PIPE: __wasi_signal_t = 13;
pub const __WASI_SIGNAL_POLL: __wasi_signal_t = 28;
pub const __WASI_SIGNAL_PROF: __wasi_signal_t = 26;
pub const __WASI_SIGNAL_PWR: __wasi_signal_t = 29;
pub const __WASI_SIGNAL_QUIT: __wasi_signal_t = 3;
pub const __WASI_SIGNAL_SEGV: __wasi_signal_t = 11;
pub const __WASI_SIGNAL_STOP: __wasi_signal_t = 18;
pub const __WASI_SIGNAL_SYS: __wasi_signal_t = 30;
pub const __WASI_SIGNAL_TERM: __wasi_signal_t = 15;
pub const __WASI_SIGNAL_TRAP: __wasi_signal_t = 5;
pub const __WASI_SIGNAL_TSTP: __wasi_signal_t = 19;
pub const __WASI_SIGNAL_TTIN: __wasi_signal_t = 20;
pub const __WASI_SIGNAL_TTOU: __wasi_signal_t = 21;
pub const __WASI_SIGNAL_URG: __wasi_signal_t = 22;
pub const __WASI_SIGNAL_USR1: __wasi_signal_t = 10;
pub const __WASI_SIGNAL_USR2: __wasi_signal_t = 12;
pub const __WASI_SIGNAL_VTALRM: __wasi_signal_t = 25;
pub const __WASI_SIGNAL_WINCH: __wasi_signal_t = 27;
pub const __WASI_SIGNAL_XCPU: __wasi_signal_t = 23;
pub const __WASI_SIGNAL_XFSZ: __wasi_signal_t = 24;
pub const __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME: __wasi_subclockflags_t = 1;
pub const __WASI_WHENCE_CUR: __wasi_whence_t = 1;
pub const __WASI_WHENCE_END: __wasi_whence_t = 2;
pub const __WASI_WHENCE_SET: __wasi_whence_t = 0;
pub fn strerror(errno: __wasi_errno_t) -> &'static str
pub fn whence_to_str(whence: __wasi_whence_t) -> &'static str
Types and constants shared between 32-bit and 64-bit wasi. Types involving
+pointer or usize-sized data are excluded here, so this file only contains
+fixed-size types, so it's host/target independent.
| __wasi_dirent_t | |
| __wasi_event_fd_readwrite_t | |
| __wasi_event_t | |
| __wasi_fdstat_t | |
| __wasi_filestat_t | |
| __wasi_subscription_clock_t | |
| __wasi_subscription_fd_readwrite_t | |
| __wasi_subscription_t |
| strerror | |
| whence_to_str |
| __wasi_event_u_t | |
| __wasi_subscription_u_t |
d_next: __wasi_dircookie_td_ino: __wasi_inode_td_namlen: __wasi_dirnamlen_td_type: __wasi_filetype_timpl Clone for __wasi_dirent_t[src]fn clone(&self) -> __wasi_dirent_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_dirent_t[src]impl Debug for __wasi_dirent_t[src]impl Eq for __wasi_dirent_t[src]impl Hash for __wasi_dirent_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_dirent_t> for __wasi_dirent_t[src]fn eq(&self, other: &__wasi_dirent_t) -> bool[src]fn ne(&self, other: &__wasi_dirent_t) -> bool[src]impl StructuralEq for __wasi_dirent_t[src]impl StructuralPartialEq for __wasi_dirent_t[src]impl RefUnwindSafe for __wasi_dirent_timpl Send for __wasi_dirent_timpl Sync for __wasi_dirent_timpl Unpin for __wasi_dirent_timpl UnwindSafe for __wasi_dirent_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]nbytes: __wasi_filesize_tflags: __wasi_eventrwflags_timpl Clone for __wasi_event_fd_readwrite_t[src]fn clone(&self) -> __wasi_event_fd_readwrite_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_fd_readwrite_t[src]impl Debug for __wasi_event_fd_readwrite_t[src]impl Eq for __wasi_event_fd_readwrite_t[src]impl Hash for __wasi_event_fd_readwrite_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_event_fd_readwrite_t> for __wasi_event_fd_readwrite_t[src]fn eq(&self, other: &__wasi_event_fd_readwrite_t) -> bool[src]fn ne(&self, other: &__wasi_event_fd_readwrite_t) -> bool[src]impl StructuralEq for __wasi_event_fd_readwrite_t[src]impl StructuralPartialEq for __wasi_event_fd_readwrite_t[src]impl RefUnwindSafe for __wasi_event_fd_readwrite_timpl Send for __wasi_event_fd_readwrite_timpl Sync for __wasi_event_fd_readwrite_timpl Unpin for __wasi_event_fd_readwrite_timpl UnwindSafe for __wasi_event_fd_readwrite_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]userdata: __wasi_userdata_terror: __wasi_errno_ttype: __wasi_eventtype_tu: __wasi_event_u_timpl Clone for __wasi_event_t[src]fn clone(&self) -> __wasi_event_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_t[src]impl RefUnwindSafe for __wasi_event_timpl Send for __wasi_event_timpl Sync for __wasi_event_timpl Unpin for __wasi_event_timpl UnwindSafe for __wasi_event_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]fs_filetype: __wasi_filetype_tfs_flags: __wasi_fdflags_tfs_rights_base: __wasi_rights_tfs_rights_inheriting: __wasi_rights_timpl Clone for __wasi_fdstat_t[src]fn clone(&self) -> __wasi_fdstat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_fdstat_t[src]impl Debug for __wasi_fdstat_t[src]impl Eq for __wasi_fdstat_t[src]impl Hash for __wasi_fdstat_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_fdstat_t> for __wasi_fdstat_t[src]fn eq(&self, other: &__wasi_fdstat_t) -> bool[src]fn ne(&self, other: &__wasi_fdstat_t) -> bool[src]impl StructuralEq for __wasi_fdstat_t[src]impl StructuralPartialEq for __wasi_fdstat_t[src]impl RefUnwindSafe for __wasi_fdstat_timpl Send for __wasi_fdstat_timpl Sync for __wasi_fdstat_timpl Unpin for __wasi_fdstat_timpl UnwindSafe for __wasi_fdstat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]dev: __wasi_device_tino: __wasi_inode_tfiletype: __wasi_filetype_tnlink: __wasi_linkcount_tsize: __wasi_filesize_tatim: __wasi_timestamp_tmtim: __wasi_timestamp_tctim: __wasi_timestamp_timpl Clone for __wasi_filestat_t[src]fn clone(&self) -> __wasi_filestat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_filestat_t[src]impl Debug for __wasi_filestat_t[src]impl Eq for __wasi_filestat_t[src]impl Hash for __wasi_filestat_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_filestat_t> for __wasi_filestat_t[src]fn eq(&self, other: &__wasi_filestat_t) -> bool[src]fn ne(&self, other: &__wasi_filestat_t) -> bool[src]impl StructuralEq for __wasi_filestat_t[src]impl StructuralPartialEq for __wasi_filestat_t[src]impl RefUnwindSafe for __wasi_filestat_timpl Send for __wasi_filestat_timpl Sync for __wasi_filestat_timpl Unpin for __wasi_filestat_timpl UnwindSafe for __wasi_filestat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]id: __wasi_clockid_ttimeout: __wasi_timestamp_tprecision: __wasi_timestamp_tflags: __wasi_subclockflags_timpl Clone for __wasi_subscription_clock_t[src]fn clone(&self) -> __wasi_subscription_clock_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_clock_t[src]impl Debug for __wasi_subscription_clock_t[src]impl Eq for __wasi_subscription_clock_t[src]impl Hash for __wasi_subscription_clock_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_subscription_clock_t> for __wasi_subscription_clock_t[src]fn eq(&self, other: &__wasi_subscription_clock_t) -> bool[src]fn ne(&self, other: &__wasi_subscription_clock_t) -> bool[src]impl StructuralEq for __wasi_subscription_clock_t[src]impl StructuralPartialEq for __wasi_subscription_clock_t[src]impl RefUnwindSafe for __wasi_subscription_clock_timpl Send for __wasi_subscription_clock_timpl Sync for __wasi_subscription_clock_timpl Unpin for __wasi_subscription_clock_timpl UnwindSafe for __wasi_subscription_clock_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]file_descriptor: __wasi_fd_timpl Clone for __wasi_subscription_fd_readwrite_t[src]fn clone(&self) -> __wasi_subscription_fd_readwrite_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_fd_readwrite_t[src]impl Debug for __wasi_subscription_fd_readwrite_t[src]impl Eq for __wasi_subscription_fd_readwrite_t[src]impl Hash for __wasi_subscription_fd_readwrite_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_subscription_fd_readwrite_t> for __wasi_subscription_fd_readwrite_t[src]fn eq(&self, other: &__wasi_subscription_fd_readwrite_t) -> bool[src]fn ne(&self, other: &__wasi_subscription_fd_readwrite_t) -> bool[src]impl StructuralEq for __wasi_subscription_fd_readwrite_t[src]impl StructuralPartialEq for __wasi_subscription_fd_readwrite_t[src]impl RefUnwindSafe for __wasi_subscription_fd_readwrite_timpl Send for __wasi_subscription_fd_readwrite_timpl Sync for __wasi_subscription_fd_readwrite_timpl Unpin for __wasi_subscription_fd_readwrite_timpl UnwindSafe for __wasi_subscription_fd_readwrite_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]userdata: __wasi_userdata_ttype: __wasi_eventtype_tu: __wasi_subscription_u_timpl Clone for __wasi_subscription_t[src]fn clone(&self) -> __wasi_subscription_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_t[src]impl RefUnwindSafe for __wasi_subscription_timpl Send for __wasi_subscription_timpl Sync for __wasi_subscription_timpl Unpin for __wasi_subscription_timpl UnwindSafe for __wasi_subscription_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type __wasi_advice_t = u8;
type __wasi_clockid_t = u32;
type __wasi_device_t = u64;
type __wasi_dircookie_t = u64;
type __wasi_dirnamlen_t = u32;
type __wasi_errno_t = u16;
type __wasi_eventrwflags_t = u16;
type __wasi_eventtype_t = u8;
type __wasi_exitcode_t = u32;
type __wasi_fd_t = u32;
type __wasi_fdflags_t = u16;
type __wasi_filedelta_t = i64;
type __wasi_filesize_t = u64;
type __wasi_filetype_t = u8;
type __wasi_fstflags_t = u16;
type __wasi_inode_t = u64;
type __wasi_linkcount_t = u64;
type __wasi_lookupflags_t = u32;
type __wasi_oflags_t = u16;
type __wasi_preopentype_t = u8;
type __wasi_riflags_t = u16;
type __wasi_rights_t = u64;
type __wasi_roflags_t = u16;
type __wasi_sdflags_t = u8;
type __wasi_siflags_t = u16;
type __wasi_signal_t = u8;
type __wasi_subclockflags_t = u16;
type __wasi_timestamp_t = u64;
type __wasi_userdata_t = u64;
type __wasi_whence_t = u8;
fd_readwrite: __wasi_event_fd_readwrite_timpl Clone for __wasi_event_u_t[src]fn clone(&self) -> __wasi_event_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_event_u_t[src]impl RefUnwindSafe for __wasi_event_u_timpl Send for __wasi_event_u_timpl Sync for __wasi_event_u_timpl Unpin for __wasi_event_u_timpl UnwindSafe for __wasi_event_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]clock: __wasi_subscription_clock_tfd_readwrite: __wasi_subscription_fd_readwrite_timpl Clone for __wasi_subscription_u_t[src]fn clone(&self) -> __wasi_subscription_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_subscription_u_t[src]impl RefUnwindSafe for __wasi_subscription_u_timpl Send for __wasi_subscription_u_timpl Sync for __wasi_subscription_u_timpl Unpin for __wasi_subscription_u_timpl UnwindSafe for __wasi_subscription_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Types and constants specific to 32-bit wasi. These are similar to the types
+in the host module, but pointers and usize values are replaced with
+u32-sized types.
| __wasi_ciovec_t | |
| __wasi_iovec_t | |
| __wasi_prestat_dir_t | |
| __wasi_prestat_t |
| __wasi_ciovec_array_t | |
| __wasi_iovec_array_t | |
| __wasi_size_t | |
| size_t | |
| uintptr_t |
| __wasi_prestat_u_t |
buf: u32buf_len: __wasi_size_timpl Clone for __wasi_ciovec_t[src]fn clone(&self) -> __wasi_ciovec_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_ciovec_t[src]impl Debug for __wasi_ciovec_t[src]impl Eq for __wasi_ciovec_t[src]impl Hash for __wasi_ciovec_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_ciovec_t> for __wasi_ciovec_t[src]fn eq(&self, other: &__wasi_ciovec_t) -> bool[src]fn ne(&self, other: &__wasi_ciovec_t) -> bool[src]impl StructuralEq for __wasi_ciovec_t[src]impl StructuralPartialEq for __wasi_ciovec_t[src]impl RefUnwindSafe for __wasi_ciovec_timpl Send for __wasi_ciovec_timpl Sync for __wasi_ciovec_timpl Unpin for __wasi_ciovec_timpl UnwindSafe for __wasi_ciovec_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]buf: u32buf_len: __wasi_size_timpl Clone for __wasi_iovec_t[src]fn clone(&self) -> __wasi_iovec_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_iovec_t[src]impl Debug for __wasi_iovec_t[src]impl Eq for __wasi_iovec_t[src]impl Hash for __wasi_iovec_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_iovec_t> for __wasi_iovec_t[src]fn eq(&self, other: &__wasi_iovec_t) -> bool[src]fn ne(&self, other: &__wasi_iovec_t) -> bool[src]impl StructuralEq for __wasi_iovec_t[src]impl StructuralPartialEq for __wasi_iovec_t[src]impl RefUnwindSafe for __wasi_iovec_timpl Send for __wasi_iovec_timpl Sync for __wasi_iovec_timpl Unpin for __wasi_iovec_timpl UnwindSafe for __wasi_iovec_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pr_name_len: __wasi_size_timpl Clone for __wasi_prestat_dir_t[src]fn clone(&self) -> __wasi_prestat_dir_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_dir_t[src]impl Debug for __wasi_prestat_dir_t[src]impl Eq for __wasi_prestat_dir_t[src]impl Hash for __wasi_prestat_dir_t[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<__wasi_prestat_dir_t> for __wasi_prestat_dir_t[src]fn eq(&self, other: &__wasi_prestat_dir_t) -> bool[src]fn ne(&self, other: &__wasi_prestat_dir_t) -> bool[src]impl StructuralEq for __wasi_prestat_dir_t[src]impl StructuralPartialEq for __wasi_prestat_dir_t[src]impl RefUnwindSafe for __wasi_prestat_dir_timpl Send for __wasi_prestat_dir_timpl Sync for __wasi_prestat_dir_timpl Unpin for __wasi_prestat_dir_timpl UnwindSafe for __wasi_prestat_dir_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pr_type: __wasi_preopentype_tu: __wasi_prestat_u_timpl Clone for __wasi_prestat_t[src]fn clone(&self) -> __wasi_prestat_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_t[src]impl RefUnwindSafe for __wasi_prestat_timpl Send for __wasi_prestat_timpl Sync for __wasi_prestat_timpl Unpin for __wasi_prestat_timpl UnwindSafe for __wasi_prestat_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type __wasi_ciovec_array_t = (u32, u32);
type __wasi_iovec_array_t = (u32, u32);
type __wasi_size_t = u32;
type size_t = u32;
type uintptr_t = u32;
dir: __wasi_prestat_dir_timpl Clone for __wasi_prestat_u_t[src]fn clone(&self) -> __wasi_prestat_u_t[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for __wasi_prestat_u_t[src]impl RefUnwindSafe for __wasi_prestat_u_timpl Send for __wasi_prestat_u_timpl Sync for __wasi_prestat_u_timpl Unpin for __wasi_prestat_u_timpl UnwindSafe for __wasi_prestat_u_timpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime/trait.Callable.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/enum.AnyRef.html b/api/wasmtime/enum.AnyRef.html new file mode 100644 index 000000000000..c4f8ccd45ff5 --- /dev/null +++ b/api/wasmtime/enum.AnyRef.html @@ -0,0 +1,42 @@ +Represents an opaque reference to any data within WebAssembly.
+A reference to no data.
+A reference to data stored internally in wasmtime.
A reference to data located outside of wasmtime.
impl AnyRef[src]pub fn new(data: Box<dyn Any>) -> Self[src]Creates a new instance of AnyRef from Box<dyn Any>.
pub fn null() -> Self[src]Creates a Null reference.
pub fn data(&self) -> Ref<Box<dyn Any>>[src]Returns the data stored in the reference if available.
+Panics if the variant isn't AnyRef::Other.
pub fn ptr_eq(&self, other: &AnyRef) -> bool[src]Returns true if the two AnyRef<T>'s point to the same value (not just
+values that compare as equal).
pub fn host_info(&self) -> Option<RefMut<Box<dyn HostInfo>>>[src]Returns a mutable reference to the host information if available.
+Panics if AnyRef is already borrowed or AnyRef is Null.
pub fn set_host_info(&self, info: Option<Box<dyn HostInfo>>)[src]Sets the host information for an AnyRef.
Panics if AnyRef is already borrowed or AnyRef is Null.
impl !RefUnwindSafe for AnyRefimpl !Send for AnyRefimpl !Sync for AnyRefimpl Unpin for AnyRefimpl !UnwindSafe for AnyRefimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An external item to a WebAssembly module, or a list of what can possibly be +exported from a wasm module.
+This is both returned from Instance::exports
+as well as required by Instance::new. In other
+words, this is the type of extracted values from an instantiated module, and
+it's also used to provide imported values when instantiating a module.
Func(Func)A WebAssembly func which can be called.
Global(Global)A WebAssembly global which acts like a Cell<T> of sorts, supporting
+get and set operations.
Table(Table)A WebAssembly table which is an array of Val types.
Memory(Memory)A WebAssembly linear memory.
+impl Extern[src]pub fn func(&self) -> Option<&Func>[src]Returns the underlying Func, if this external is a function.
Returns None if this is not a function.
pub fn global(&self) -> Option<&Global>[src]Returns the underlying Global, if this external is a global.
Returns None if this is not a global.
pub fn table(&self) -> Option<&Table>[src]Returns the underlying Table, if this external is a table.
Returns None if this is not a table.
pub fn memory(&self) -> Option<&Memory>[src]Returns the underlying Memory, if this external is a memory.
Returns None if this is not a memory.
pub fn ty(&self) -> ExternType[src]Returns the type associated with this Extern.
impl Clone for Extern[src]impl From<Func> for Extern[src]impl From<Global> for Extern[src]impl From<Memory> for Extern[src]impl From<Table> for Extern[src]impl !RefUnwindSafe for Externimpl !Send for Externimpl !Sync for Externimpl Unpin for Externimpl !UnwindSafe for Externimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A list of all possible types which can be externally referenced from a +WebAssembly module.
+This list can be found in ImportType or ExportType, so these types
+can either be imported or exported.
Func(FuncType)This external type is the type of a WebAssembly function.
+Global(GlobalType)This external type is the type of a WebAssembly global.
+Table(TableType)This external type is the type of a WebAssembly table.
+Memory(MemoryType)This external type is the type of a WebAssembly memory.
+impl ExternType[src]pub fn func(&self) -> Option<&FuncType>[src]Attempt to return the underlying type of this external type,
+returning None if it is a different type.
pub fn unwrap_func(&self) -> &FuncType[src]Returns the underlying descriptor of this ExternType, panicking
+if it is a different type.
Panics if self is not of the right type.
pub fn global(&self) -> Option<&GlobalType>[src]Attempt to return the underlying type of this external type,
+returning None if it is a different type.
pub fn unwrap_global(&self) -> &GlobalType[src]Returns the underlying descriptor of this ExternType, panicking
+if it is a different type.
Panics if self is not of the right type.
pub fn table(&self) -> Option<&TableType>[src]Attempt to return the underlying type of this external type,
+returning None if it is a different type.
pub fn unwrap_table(&self) -> &TableType[src]Returns the underlying descriptor of this ExternType, panicking
+if it is a different type.
Panics if self is not of the right type.
pub fn memory(&self) -> Option<&MemoryType>[src]Attempt to return the underlying type of this external type,
+returning None if it is a different type.
pub fn unwrap_memory(&self) -> &MemoryType[src]Returns the underlying descriptor of this ExternType, panicking
+if it is a different type.
Panics if self is not of the right type.
impl Clone for ExternType[src]fn clone(&self) -> ExternType[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ExternType[src]impl RefUnwindSafe for ExternTypeimpl Send for ExternTypeimpl Sync for ExternTypeimpl Unpin for ExternTypeimpl UnwindSafe for ExternTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Indicator of whether a global is mutable or not
+The global is constant and its value does not change
+The value of the global can change over time
+impl Clone for Mutability[src]fn clone(&self) -> Mutability[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Mutability[src]impl Debug for Mutability[src]impl PartialEq<Mutability> for Mutability[src]fn eq(&self, other: &Mutability) -> bool[src]#[must_use]
+fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralPartialEq for Mutability[src]impl RefUnwindSafe for Mutabilityimpl Send for Mutabilityimpl Sync for Mutabilityimpl Unpin for Mutabilityimpl UnwindSafe for Mutabilityimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Possible optimization levels for the Cranelift codegen backend.
+No optimizations performed, minimizes compilation time by disabling most +optimizations.
+Generates the fastest possible code, but may take longer.
+Similar to speed, but also performs transformations aimed at reducing
+code size.
impl RefUnwindSafe for OptLevelimpl Send for OptLevelimpl Sync for OptLevelimpl Unpin for OptLevelimpl UnwindSafe for OptLevelimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Possible Compilation strategies for a wasm module.
+This is used as an argument to the Config::strategy method.
An indicator that the compilation strategy should be automatically +selected.
+This is generally what you want for most projects and indicates that the
+wasmtime crate itself should make the decision about what the best
+code generator for a wasm module is.
Currently this always defaults to Cranelift, but the default value will +change over time.
+Currently the default backend, Cranelift aims to be a reasonably fast +code generator which generates high quality machine code.
+A single-pass code generator that is faster than Cranelift but doesn't +produce as high-quality code.
+To successfully pass this argument to Config::strategy the
+lightbeam feature of this crate must be enabled.
impl RefUnwindSafe for Strategyimpl Send for Strategyimpl Sync for Strategyimpl Unpin for Strategyimpl UnwindSafe for Strategyimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Possible runtime values that a WebAssembly module can either consume or +produce.
+I32(i32)A 32-bit integer
+I64(i64)A 64-bit integer
+F32(u32)A 32-bit float.
+Note that the raw bits of the float are stored here, and you can use
+f32::from_bits to create an f32 value.
F64(u64)A 64-bit float.
+Note that the raw bits of the float are stored here, and you can use
+f64::from_bits to create an f64 value.
AnyRef(AnyRef)An anyref value which can hold opaque data to the wasm instance itself.
Note that this is a nullable value as well.
+FuncRef(Func)A first-class reference to a WebAssembly function.
+V128(u128)A 128-bit number
+impl Val[src]pub fn null() -> Val[src]Returns a null anyref value.
pub fn ty(&self) -> ValType[src]Returns the corresponding ValType for this Val.
pub fn i32(&self) -> Option<i32>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_i32(&self) -> i32[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn i64(&self) -> Option<i64>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_i64(&self) -> i64[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn f32(&self) -> Option<f32>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_f32(&self) -> f32[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn f64(&self) -> Option<f64>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_f64(&self) -> f64[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn funcref(&self) -> Option<&Func>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_funcref(&self) -> &Func[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn v128(&self) -> Option<u128>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
pub fn unwrap_v128(&self) -> u128[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
pub fn anyref(&self) -> Option<AnyRef>[src]Attempt to access the underlying value of this Val, returning
+None if it is not the correct type.
This will return Some for both the AnyRef and FuncRef types.
pub fn unwrap_anyref(&self) -> AnyRef[src]Returns the underlying value of this Val, panicking if it's the
+wrong type.
Panics if self is not of the right type.
impl Clone for Val[src]impl Debug for Val[src]impl From<AnyRef> for Val[src]impl From<Func> for Val[src]impl From<f32> for Val[src]impl From<f64> for Val[src]impl From<i32> for Val[src]impl From<i64> for Val[src]impl !RefUnwindSafe for Valimpl !Send for Valimpl !Sync for Valimpl Unpin for Valimpl !UnwindSafe for Valimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A list of all possible value types in WebAssembly.
+Signed 32 bit integer.
+Signed 64 bit integer.
+Floating point 32 bit integer.
+Floating point 64 bit integer.
+A 128 bit number.
+A reference to opaque data in the Wasm instance.
+A reference to a Wasm function.
+impl ValType[src]pub fn is_num(&self) -> bool[src]Returns true if ValType matches any of the numeric types. (e.g. I32,
+I64, F32, F64).
pub fn is_ref(&self) -> bool[src]Returns true if ValType matches either of the reference types.
impl Clone for ValType[src]impl Debug for ValType[src]impl Eq for ValType[src]impl PartialEq<ValType> for ValType[src]impl StructuralEq for ValType[src]impl StructuralPartialEq for ValType[src]impl RefUnwindSafe for ValTypeimpl Send for ValTypeimpl Sync for ValTypeimpl Unpin for ValTypeimpl UnwindSafe for ValTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime/enum.Extern.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/externals/struct.Global.html b/api/wasmtime/externals/struct.Global.html new file mode 100644 index 000000000000..a71b770f4ee2 --- /dev/null +++ b/api/wasmtime/externals/struct.Global.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Global.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/externals/struct.Memory.html b/api/wasmtime/externals/struct.Memory.html new file mode 100644 index 000000000000..12ef49c421e1 --- /dev/null +++ b/api/wasmtime/externals/struct.Memory.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Memory.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/externals/struct.Table.html b/api/wasmtime/externals/struct.Table.html new file mode 100644 index 000000000000..d68cd5d571d3 --- /dev/null +++ b/api/wasmtime/externals/struct.Table.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Table.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/frame_info/struct.FrameInfo.html b/api/wasmtime/frame_info/struct.FrameInfo.html new file mode 100644 index 000000000000..d0754d75c84f --- /dev/null +++ b/api/wasmtime/frame_info/struct.FrameInfo.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.FrameInfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/func/struct.Func.html b/api/wasmtime/func/struct.Func.html new file mode 100644 index 000000000000..31ac0f0b9a4d --- /dev/null +++ b/api/wasmtime/func/struct.Func.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Func.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/func/trait.WasmRet.html b/api/wasmtime/func/trait.WasmRet.html new file mode 100644 index 000000000000..dc5250344eab --- /dev/null +++ b/api/wasmtime/func/trait.WasmRet.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/trait.WasmRet.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/func/trait.WasmTy.html b/api/wasmtime/func/trait.WasmTy.html new file mode 100644 index 000000000000..4cdbeded1e34 --- /dev/null +++ b/api/wasmtime/func/trait.WasmTy.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/trait.WasmTy.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/index.html b/api/wasmtime/index.html new file mode 100644 index 000000000000..bcf1b4d7a0ad --- /dev/null +++ b/api/wasmtime/index.html @@ -0,0 +1,52 @@ +Wasmtime's embedding API
+This crate contains a high-level API used to interact with WebAssembly +modules. The API here is intended to mirror the proposed WebAssembly C +API, with small extensions here +and there to implement Rust idioms. This crate also defines the actual C API +itself for consumption from other languages.
+| unix | Unix-specific extension for the |
| Config | Global configuration options used to create an |
| Engine | An |
| ExportType | A descriptor for an exported WebAssembly value. + |
| FrameInfo | Description of a frame in a backtrace for a [ |
| Func | A WebAssembly function which can be called. + |
| FuncType | A descriptor for a function in a WebAssembly module. + |
| Global | A WebAssembly |
| GlobalType | A WebAssembly global descriptor. + |
| HostRef | Represents a piece of data located in the host environment. + |
| ImportType | A descriptor for an imported value into a wasm module. + |
| Instance | An instantiated WebAssembly module. + |
| Limits | Limits of tables/memories where the units of the limits are defined by the +table/memory types. + |
| Memory | A WebAssembly linear memory. + |
| MemoryType | A descriptor for a WebAssembly memory type. + |
| Module | A compiled WebAssembly module, ready to be instantiated. + |
| Store | A |
| Table | A WebAssembly |
| TableType | A descriptor for a table in a WebAssembly module. + |
| Trap | A struct representing an aborted instruction execution, with a message +indicating the cause. + |
| AnyRef | Represents an opaque reference to any data within WebAssembly. + |
| Extern | An external item to a WebAssembly module, or a list of what can possibly be +exported from a wasm module. + |
| ExternType | A list of all possible types which can be externally referenced from a +WebAssembly module. + |
| Mutability | Indicator of whether a global is mutable or not + |
| OptLevel | Possible optimization levels for the Cranelift codegen backend. + |
| Strategy | Possible Compilation strategies for a wasm module. + |
| Val | Possible runtime values that a WebAssembly module can either consume or +produce. + |
| ValType | A list of all possible value types in WebAssembly. + |
| Callable | A trait representing a function that can be imported and called from inside +WebAssembly. + |
| HostInfo | |
| WasmRet | A trait implemented for types which can be returned from closures passed to
+ |
| WasmTy | A trait implemented for types which can be arguments to closures passed to
+ |
Redirecting to ../../wasmtime/struct.Instance.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/module/struct.Module.html b/api/wasmtime/module/struct.Module.html new file mode 100644 index 000000000000..cc95f8b9089f --- /dev/null +++ b/api/wasmtime/module/struct.Module.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Module.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/ref/enum.AnyRef.html b/api/wasmtime/ref/enum.AnyRef.html new file mode 100644 index 000000000000..8df507fb5a1a --- /dev/null +++ b/api/wasmtime/ref/enum.AnyRef.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.AnyRef.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/ref/struct.HostRef.html b/api/wasmtime/ref/struct.HostRef.html new file mode 100644 index 000000000000..c15415726cb0 --- /dev/null +++ b/api/wasmtime/ref/struct.HostRef.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.HostRef.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/ref/trait.HostInfo.html b/api/wasmtime/ref/trait.HostInfo.html new file mode 100644 index 000000000000..35e4a584dd71 --- /dev/null +++ b/api/wasmtime/ref/trait.HostInfo.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/trait.HostInfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/runtime/enum.OptLevel.html b/api/wasmtime/runtime/enum.OptLevel.html new file mode 100644 index 000000000000..6f9336789bf3 --- /dev/null +++ b/api/wasmtime/runtime/enum.OptLevel.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.OptLevel.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/runtime/enum.Strategy.html b/api/wasmtime/runtime/enum.Strategy.html new file mode 100644 index 000000000000..700cfd5c4b47 --- /dev/null +++ b/api/wasmtime/runtime/enum.Strategy.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.Strategy.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/runtime/struct.Config.html b/api/wasmtime/runtime/struct.Config.html new file mode 100644 index 000000000000..bbdc3a956005 --- /dev/null +++ b/api/wasmtime/runtime/struct.Config.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Config.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/runtime/struct.Engine.html b/api/wasmtime/runtime/struct.Engine.html new file mode 100644 index 000000000000..60b9aef59544 --- /dev/null +++ b/api/wasmtime/runtime/struct.Engine.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Engine.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/runtime/struct.Store.html b/api/wasmtime/runtime/struct.Store.html new file mode 100644 index 000000000000..58e38d39ed50 --- /dev/null +++ b/api/wasmtime/runtime/struct.Store.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Store.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/sidebar-items.js b/api/wasmtime/sidebar-items.js new file mode 100644 index 000000000000..1c30aae9521c --- /dev/null +++ b/api/wasmtime/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"enum":[["AnyRef","Represents an opaque reference to any data within WebAssembly."],["Extern","An external item to a WebAssembly module, or a list of what can possibly be exported from a wasm module."],["ExternType","A list of all possible types which can be externally referenced from a WebAssembly module."],["Mutability","Indicator of whether a global is mutable or not"],["OptLevel","Possible optimization levels for the Cranelift codegen backend."],["Strategy","Possible Compilation strategies for a wasm module."],["Val","Possible runtime values that a WebAssembly module can either consume or produce."],["ValType","A list of all possible value types in WebAssembly."]],"mod":[["unix","Unix-specific extension for the `wasmtime` crate."]],"struct":[["Config","Global configuration options used to create an [`Engine`] and customize its behavior."],["Engine","An `Engine` which is a global context for compilation and management of wasm modules."],["ExportType","A descriptor for an exported WebAssembly value."],["FrameInfo","Description of a frame in a backtrace for a [`Trap`]."],["Func","A WebAssembly function which can be called."],["FuncType","A descriptor for a function in a WebAssembly module."],["Global","A WebAssembly `global` value which can be read and written to."],["GlobalType","A WebAssembly global descriptor."],["HostRef","Represents a piece of data located in the host environment."],["ImportType","A descriptor for an imported value into a wasm module."],["Instance","An instantiated WebAssembly module."],["Limits","Limits of tables/memories where the units of the limits are defined by the table/memory types."],["Memory","A WebAssembly linear memory."],["MemoryType","A descriptor for a WebAssembly memory type."],["Module","A compiled WebAssembly module, ready to be instantiated."],["Store","A `Store` is a shared cache of information between WebAssembly modules."],["Table","A WebAssembly `table`, or an array of values."],["TableType","A descriptor for a table in a WebAssembly module."],["Trap","A struct representing an aborted instruction execution, with a message indicating the cause."]],"trait":[["Callable","A trait representing a function that can be imported and called from inside WebAssembly. # Example ``` use wasmtime::Val;"],["HostInfo",""],["WasmRet","A trait implemented for types which can be returned from closures passed to [`Func::wrap1`] and friends."],["WasmTy","A trait implemented for types which can be arguments to closures passed to [`Func::wrap1`] and friends."]]}); \ No newline at end of file diff --git a/api/wasmtime/struct.Config.html b/api/wasmtime/struct.Config.html new file mode 100644 index 000000000000..c8a12a9dd52c --- /dev/null +++ b/api/wasmtime/struct.Config.html @@ -0,0 +1,120 @@ +Global configuration options used to create an Engine and customize its
+behavior.
This structure exposed a builder-like interface and is primarily consumed by
+Engine::new()
impl Config[src]pub fn new() -> Config[src]Creates a new configuration object with the default configuration +specified.
+pub fn debug_info(&mut self, enable: bool) -> &mut Self[src]Configures whether DWARF debug information will be emitted during +compilation.
+By default this option is false.
pub fn wasm_threads(&mut self, enable: bool) -> &mut Self[src]Configures whether the WebAssembly threads proposal will be enabled for +compilation.
+The WebAssembly threads proposal is not currently fully +standardized and is undergoing development. Additionally the support in +wasmtime itself is still being worked on. Support for this feature can +be enabled through this method for appropriate wasm modules.
+This feature gates items such as shared memories and atomic +instructions. Note that enabling the threads feature will +also enable the bulk memory feature.
+This is false by default.
pub fn wasm_reference_types(&mut self, enable: bool) -> &mut Self[src]Configures whether the WebAssembly reference types proposal will be +enabled for compilation.
+The WebAssembly reference types proposal is not currently +fully standardized and is undergoing development. Additionally the +support in wasmtime itself is still being worked on. Support for this +feature can be enabled through this method for appropriate wasm +modules.
+This feature gates items such as the anyref type and multiple tables
+being in a module. Note that enabling the reference types feature will
+also enable the bulk memory feature.
This is false by default.
pub fn wasm_simd(&mut self, enable: bool) -> &mut Self[src]Configures whether the WebAssembly SIMD proposal will be +enabled for compilation.
+The WebAssembly SIMD proposal is not currently +fully standardized and is undergoing development. Additionally the +support in wasmtime itself is still being worked on. Support for this +feature can be enabled through this method for appropriate wasm +modules.
+This feature gates items such as the v128 type and all of its
+operators being in a module.
This is false by default.
pub fn wasm_bulk_memory(&mut self, enable: bool) -> &mut Self[src]Configures whether the WebAssembly bulk memory operations proposal will +be enabled for compilation.
+The WebAssembly bulk memory operations proposal is not +currently fully standardized and is undergoing development. +Additionally the support in wasmtime itself is still being worked on. +Support for this feature can be enabled through this method for +appropriate wasm modules.
+This feature gates items such as the memory.copy instruction, passive
+data/table segments, etc, being in a module.
This is false by default.
pub fn wasm_multi_value(&mut self, enable: bool) -> &mut Self[src]Configures whether the WebAssembly multi-value proposal will +be enabled for compilation.
+The WebAssembly multi-value proposal is not +currently fully standardized and is undergoing development. +Additionally the support in wasmtime itself is still being worked on. +Support for this feature can be enabled through this method for +appropriate wasm modules.
+This feature gates functions and blocks returning multiple values in a +module, for example.
+This is false by default.
pub fn strategy(&mut self, strategy: Strategy) -> Result<&mut Self>[src]Configures which compilation strategy will be used for wasm modules.
+This method can be used to configure which compiler is used for wasm
+modules, and for more documentation consult the Strategy enumeration
+and its documentation.
The default value for this is Strategy::Auto.
Some compilation strategies require compile-time options of wasmtime
+itself to be set, but if they're not set and the strategy is specified
+here then an error will be returned.
pub fn cranelift_debug_verifier(&mut self, enable: bool) -> &mut Self[src]Configures whether the debug verifier of Cranelift is enabled or not.
+When Cranelift is used as a code generation backend this will configure
+it to have the enable_verifier flag which will enable a number of debug
+checks inside of Cranelift. This is largely only useful for the
+developers of wasmtime itself.
The default value for this is false
pub fn cranelift_opt_level(&mut self, level: OptLevel) -> &mut Self[src]Configures the Cranelift code generator optimization level.
+When the Cranelift code generator is used you can configure the
+optimization level used for generated code in a few various ways. For
+more information see the documentation of OptLevel.
The default value for this is OptLevel::None.
pub fn cache_config_load(&mut self, path: impl AsRef<Path>) -> Result<&mut Self>[src]Loads cache configuration specified at path.
This method will read the file specified by path on the filesystem and
+attempt to load cache configuration from it. This method can also fail
+due to I/O errors, misconfiguration, syntax errors, etc. For expected
+syntax in the configuration file see the documentation online.
By default cache configuration is not enabled or loaded.
+This method can fail due to any error that happens when loading the file
+pointed to by path and attempting to load the cache configuration.
pub fn cache_config_load_default(&mut self) -> Result<&mut Self>[src]Loads cache configuration from the system default path.
+This commit is the same as Config::cache_config_load except that it
+does not take a path argument and instead loads the default
+configuration present on the system. This is located, for example, on
+Unix at $HOME/.config/wasmtime/config.toml and is typically created
+with the wasmtime config new command.
By default cache configuration is not enabled or loaded.
+This method can fail due to any error that happens when loading the +default system configuration. Note that it is not an error if the +default config file does not exist, in which case the default settings +for an enabled cache are applied.
+impl RefUnwindSafe for Configimpl Send for Configimpl Sync for Configimpl Unpin for Configimpl UnwindSafe for Configimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An Engine which is a global context for compilation and management of wasm
+modules.
An engine can be safely shared across threads and is a cheap cloneable +handle to the actual engine. The engine itself will be deallocate once all +references to it have gone away.
+Engines store global configuration preferences such as compilation settings, +enabled features, etc. You'll likely only need at most one of these for a +program.
+CloneUsing clone on an Engine is a cheap operation. It will not create an
+entirely new engine, but rather just a new reference to the existing engine.
+In other words it's a shallow copy, not a deep copy.
DefaultYou can create an engine with default configuration settings using
+Engine::default(). Be sure to consult the documentation of Config for
+default settings.
impl Engine[src]pub fn new(config: &Config) -> Engine[src]Creates a new Engine with the specified compilation and
+configuration settings.
pub fn config(&self) -> &Config[src]Returns the configuration settings that this engine is using.
+impl RefUnwindSafe for Engineimpl Send for Engineimpl Sync for Engineimpl Unpin for Engineimpl UnwindSafe for Engineimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A descriptor for an exported WebAssembly value.
+This type is primarily accessed from the
+Module::exports accessor and describes what
+names are exported from a wasm module and the type of the item that is
+exported.
impl ExportType[src]pub fn new(name: &str, ty: ExternType) -> ExportType[src]Creates a new export which is exported with the given name and has the
+given ty.
pub fn name(&self) -> &str[src]Returns the name by which this export is known by.
+pub fn ty(&self) -> &ExternType[src]Returns the type of this export.
+impl Clone for ExportType[src]fn clone(&self) -> ExportType[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ExportType[src]impl RefUnwindSafe for ExportTypeimpl Send for ExportTypeimpl Sync for ExportTypeimpl Unpin for ExportTypeimpl UnwindSafe for ExportTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Description of a frame in a backtrace for a [Trap].
Whenever a WebAssembly trap occurs an instance of [Trap] is created. Each
+[Trap] has a backtrace of the WebAssembly frames that led to the trap, and
+each frame is described by this structure.
impl FrameInfo[src]pub fn func_index(&self) -> u32[src]Returns the WebAssembly function index for this frame.
+This function index is the index in the function index space of the +WebAssembly module that this frame comes from.
+pub fn module_name(&self) -> Option<&str>[src]Returns the identifer of the module that this frame is for.
+Module identifiers are present in the name section of a WebAssembly
+binary, but this may not return the exact item in the name section.
+Module names can be overwritten at construction time or perhaps inferred
+from file names. The primary purpose of this function is to assist in
+debugging and therefore may be tweaked over time.
This function returns None when no name can be found or inferred.
pub fn func_name(&self) -> Option<&str>[src]Returns a descriptive name of the function for this frame, if one is +available.
+The name of this function may come from the name section of the
+WebAssembly binary, or wasmtime may try to infer a better name for it if
+not available, for example the name of the export if it's exported.
This return value is primarily used for debugging and human-readable +purposes for things like traps. Note that the exact return value may be +tweaked over time here and isn't guaranteed to be something in +particular about a wasm module due to its primary purpose of assisting +in debugging.
+This function returns None when no name could be inferred.
impl RefUnwindSafe for FrameInfoimpl Send for FrameInfoimpl Sync for FrameInfoimpl Unpin for FrameInfoimpl UnwindSafe for FrameInfoimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly function which can be called.
+This type can represent a number of callable items, such as:
+These types of callable items are all wrapped up in this Func and can be
+used to both instantiate an Instance as well as be
+extracted from an Instance.
Func and CloneFunctions are internally reference counted so you can clone a Func. The
+cloning process only performs a shallow clone, so two cloned Func
+instances are equivalent in their functionality.
impl Func[src]pub fn new(
store: &Store,
ty: FuncType,
callable: Rc<dyn Callable + 'static>
) -> Self[src]Creates a new Func with the given arguments, typically to create a
+user-defined function to pass as an import to a module.
store - a cache of data where information is stored, typically
+shared with a Module.
ty - the signature of this function, used to indicate what the
+inputs and outputs are, which must be WebAssembly types.
callable - a type implementing the Callable trait which
+is the implementation of this Func value.
Note that the implementation of callable must adhere to the ty
+signature given, error or traps may occur if it does not respect the
+ty signature.
pub fn wrap0<F, R>(store: &Store, func: F) -> Func where
F: Fn() -> R + 'static,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 0
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap1<F, A, R>(store: &Store, func: F) -> Func where
F: Fn(A) -> R + 'static,
A: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 1
+argument.
This function will create a new Func which, when called, will
+execute the given Rust closure. Unlike Func::new the target
+function being called is known statically so the type signature can
+be inferred. Rust types will map to WebAssembly types as follows:
| Rust Argument Type | WebAssembly Type |
|---|---|
i32 | i32 |
i64 | i64 |
f32 | f32 |
f64 | f64 |
| (not supported) | v128 |
| (not supported) | anyref |
Any of the Rust types can be returned from the closure as well, in +addition to some extra types
+| Rust Return Type | WebAssembly Return Type | Meaning |
|---|---|---|
() | nothing | no return value |
Result<T, Trap> | T | function may trap |
Note that when using this API (and the related wrap* family of
+functions), the intention is to create as thin of a layer as
+possible for when WebAssembly calls the function provided. With
+sufficient inlining and optimization the WebAssembly will call
+straight into func provided, with no extra fluff entailed.
pub fn wrap2<F, A, B, R>(store: &Store, func: F) -> Func where
F: Fn(A, B) -> R + 'static,
A: WasmTy,
B: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 2
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap3<F, A, B, C, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 3
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap4<F, A, B, C, D, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 4
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap5<F, A, B, C, D, E, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D, E) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 5
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap6<F, A, B, C, D, E, G, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D, E, G) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
G: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 6
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap7<F, A, B, C, D, E, G, H, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D, E, G, H) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
G: WasmTy,
H: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 7
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap8<F, A, B, C, D, E, G, H, I, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D, E, G, H, I) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
G: WasmTy,
H: WasmTy,
I: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 8
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap9<F, A, B, C, D, E, G, H, I, J, R>(store: &Store, func: F) -> Func where
F: Fn(A, B, C, D, E, G, H, I, J) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
G: WasmTy,
H: WasmTy,
I: WasmTy,
J: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 9
+arguments.
For more information about this function, see Func::wrap1.
pub fn wrap10<F, A, B, C, D, E, G, H, I, J, K, R>(
store: &Store,
func: F
) -> Func where
F: Fn(A, B, C, D, E, G, H, I, J, K) -> R + 'static,
A: WasmTy,
B: WasmTy,
C: WasmTy,
D: WasmTy,
E: WasmTy,
G: WasmTy,
H: WasmTy,
I: WasmTy,
J: WasmTy,
K: WasmTy,
R: WasmRet, [src]Creates a new Func from the given Rust closure, which takes 10
+arguments.
For more information about this function, see Func::wrap1.
pub fn ty(&self) -> &FuncType[src]Returns the underlying wasm type that this Func has.
pub fn param_arity(&self) -> usize[src]Returns the number of parameters that this function takes.
+pub fn result_arity(&self) -> usize[src]Returns the number of results this function produces.
+pub fn call(&self, params: &[Val]) -> Result<Box<[Val]>, Trap>[src]Invokes this function with the params given, returning the results and
+any trap, if one occurs.
The params here must match the type signature of this Func, or a
+trap will occur. If a trap occurs while executing this function, then a
+trap will also be returned.
This function should not panic unless the underlying function itself +initiates a panic.
+pub fn get0<R>(&self) -> Option<impl Fn() -> Result<R, Trap>> where
R: WasmTy, [src]Extracts a natively-callable object from this Func, if the
+signature matches.
See the Func::get1 method for more documentation.
pub fn get1<A, R>(&self) -> Option<impl Fn(A) -> Result<R, Trap>> where
A: WasmTy,
R: WasmTy, [src]Extracts a natively-callable object from this Func, if the
+signature matches.
This function serves as an optimized version of the Func::call
+method if the type signature of a function is statically known to
+the program. This method is faster than call on a few metrics:
For more information about which Rust types match up to which wasm
+types, see the documentation on Func::wrap1.
This function will return None if the type signature asserted
+statically does not match the runtime type signature. Some,
+however, will be returned if the underlying function takes one
+parameter of type A and returns the parameter R. Currently R
+can either be () (no return values) or one wasm type. At this time
+a multi-value return isn't supported.
The returned closure will always return a Result<R, Trap> and an
+Err is returned if a trap happens while the wasm is executing.
pub fn get2<A, B, R>(&self) -> Option<impl Fn(A, B) -> Result<R, Trap>> where
A: WasmTy,
B: WasmTy,
R: WasmTy, [src]Extracts a natively-callable object from this Func, if the
+signature matches.
See the Func::get1 method for more documentation.
impl Clone for Func[src]impl Debug for Func[src]impl From<Func> for Extern[src]impl From<Func> for Val[src]impl !RefUnwindSafe for Funcimpl !Send for Funcimpl !Sync for Funcimpl Unpin for Funcimpl !UnwindSafe for Funcimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A descriptor for a function in a WebAssembly module.
+WebAssembly functions can have 0 or more parameters and results.
+impl FuncType[src]pub fn new(params: Box<[ValType]>, results: Box<[ValType]>) -> FuncType[src]Creates a new function descriptor from the given parameters and results.
+The function descriptor returned will represent a function which takes
+params as arguments and returns results when it is finished.
pub fn params(&self) -> &[ValType][src]Returns the list of parameter types for this function.
+pub fn results(&self) -> &[ValType][src]Returns the list of result types for this function.
+impl RefUnwindSafe for FuncTypeimpl Send for FuncTypeimpl Sync for FuncTypeimpl Unpin for FuncTypeimpl UnwindSafe for FuncTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly global value which can be read and written to.
A global in WebAssembly is sort of like a global variable within an
+Instance. The global.get and global.set
+instructions will modify and read global values in a wasm module. Globals
+can either be imported or exported from wasm modules.
If you're familiar with Rust already you can think of a Global as a sort
+of Rc<Cell<Val>>, more or less.
Global and CloneGlobals are internally reference counted so you can clone a Global. The
+cloning process only performs a shallow clone, so two cloned Global
+instances are equivalent in their functionality.
impl Global[src]pub fn new(store: &Store, ty: GlobalType, val: Val) -> Result<Global>[src]Creates a new WebAssembly global value with the provide type ty and
+initial value val.
The store argument provided is used as a general global cache for
+information, and otherwise the ty and val arguments are used to
+initialize the global.
Returns an error if the ty provided does not match the type of the
+value val.
pub fn ty(&self) -> &GlobalType[src]Returns the underlying type of this global.
pub fn get(&self) -> Val[src]Returns the current Val of this global.
pub fn set(&self, val: Val) -> Result<()>[src]impl !RefUnwindSafe for Globalimpl !Send for Globalimpl !Sync for Globalimpl Unpin for Globalimpl !UnwindSafe for Globalimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly global descriptor.
+This type describes an instance of a global in a WebAssembly module. Globals
+are local to an Instance and are either immutable or
+mutable.
impl GlobalType[src]pub fn new(content: ValType, mutability: Mutability) -> GlobalType[src]Creates a new global descriptor of the specified content type and
+whether or not it's mutable.
pub fn content(&self) -> &ValType[src]Returns the value type of this global descriptor.
+pub fn mutability(&self) -> Mutability[src]Returns whether or not this global is mutable.
+impl Clone for GlobalType[src]fn clone(&self) -> GlobalType[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for GlobalType[src]impl RefUnwindSafe for GlobalTypeimpl Send for GlobalTypeimpl Sync for GlobalTypeimpl Unpin for GlobalTypeimpl UnwindSafe for GlobalTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Represents a piece of data located in the host environment.
+impl<T: 'static> HostRef<T>[src]pub fn new(item: T) -> HostRef<T>[src]Creates a new HostRef<T> from T.
pub fn borrow(&self) -> Ref<T>[src]pub fn borrow_mut(&self) -> RefMut<T>[src]pub fn ptr_eq(&self, other: &HostRef<T>) -> bool[src]Returns true if the two HostRef<T>'s point to the same value (not just
+values that compare as equal).
pub fn anyref(&self) -> AnyRef[src]Returns an opaque reference to the wrapped data in the form of
+an AnyRef.
Panics if HostRef<T> is already mutably borrowed.
impl<T> !RefUnwindSafe for HostRef<T>impl<T> !Send for HostRef<T>impl<T> !Sync for HostRef<T>impl<T> Unpin for HostRef<T>impl<T> !UnwindSafe for HostRef<T>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A descriptor for an imported value into a wasm module.
+This type is primarily accessed from the
+Module::imports API. Each ImportType
+describes an import into the wasm module with the module/name that it's
+imported from as well as the type of item that's being imported.
impl ImportType[src]pub fn new(module: &str, name: &str, ty: ExternType) -> ImportType[src]Creates a new import descriptor which comes from module and name and
+is of type ty.
pub fn module(&self) -> &str[src]Returns the module name that this import is expected to come from.
+pub fn name(&self) -> &str[src]Returns the field name of the module that this import is expected to +come from.
+pub fn ty(&self) -> &ExternType[src]Returns the expected type of this import.
+impl Clone for ImportType[src]fn clone(&self) -> ImportType[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ImportType[src]impl RefUnwindSafe for ImportTypeimpl Send for ImportTypeimpl Sync for ImportTypeimpl Unpin for ImportTypeimpl UnwindSafe for ImportTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An instantiated WebAssembly module.
+This type represents the instantiation of a Module. Once instantiated
+you can access the exports which are of type
+Extern and provide the ability to call functions, set globals, read
+memory, etc. This is where all the fun stuff happens!
An Instance is created from two inputs, a Module and a list of
+imports, provided as a list of Extern values. The Module is the wasm
+code that was compiled and we're instantiating, and the Extern imports
+are how we're satisfying the imports of the module provided. On successful
+instantiation an Instance will automatically invoke the wasm start
+function.
When interacting with any wasm code you'll want to make an Instance to
+call any code or execute anything!
impl Instance[src]pub fn new(module: &Module, imports: &[Extern]) -> Result<Instance, Error>[src]Creates a new Instance from the previously compiled Module and
+list of imports specified.
This method instantiates the module provided with the imports,
+following the procedure in the core specification to
+instantiate. Instantiation can fail for a number of reasons (many
+specified below), but if successful the start function will be
+automatically run (if provided) and then the Instance will be
+returned.
The imports array here is a bit tricky. The entries in the list of
+imports are intended to correspond 1:1 with the list of imports
+returned by Module::imports. Before calling Instance::new you'll
+want to inspect the return value of Module::imports and, for each
+import type, create an Extern which corresponds to that type.
+These Extern values are all then collected into a list and passed to
+this function.
Note that this function is intentionally relatively low level. It is the +intention that we'll soon provide a higher level API which will +be much more ergonomic for instantiating modules. If you need the full +power of customization of imports, though, this is the method for you!
+This function can fail for a number of reasons, including, but not +limited to:
+imports provided doesn't match the number of imports
+returned by the module's Module::imports method.Extern doesn't match the corresponding
+[ExternType] entry that it maps to.start function in the instance, if present, traps.When instantiation fails it's recommended to inspect the return value to
+see why it failed, or bubble it upwards. If you'd like to specifically
+check for trap errors, you can use error.downcast::<Trap>().
pub fn store(&self) -> &Store[src]Returns the associated Store that this Instance is compiled into.
This is the Store that generally serves as a sort of global cache
+for various instance-related things.
pub fn module(&self) -> &Module[src]Returns the associated Module that this Instance instantiated.
The corresponding Module here is a static version of this Instance
+which can be used to learn information such as naming information about
+various functions.
pub fn exports(&self) -> &[Extern][src]Returns the list of exported items from this Instance.
Note that the exports here do not have names associated with them,
+they're simply the values that are exported. To learn the value of each
+export you'll need to consult Module::exports. The list returned
+here maps 1:1 with the list that Module::exports returns, and
+[ExportType] contains the name of each export.
pub fn get_export(&self, name: &str) -> Option<&Extern>[src]Looks up an exported Extern value by name.
This method will search the module for an export named name and return
+the value, if found.
Returns None if there was no export named name.
impl !RefUnwindSafe for Instanceimpl !Send for Instanceimpl !Sync for Instanceimpl Unpin for Instanceimpl !UnwindSafe for Instanceimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Limits of tables/memories where the units of the limits are defined by the +table/memory types.
+A minimum is always available but the maximum may not be present.
+impl Limits[src]pub fn new(min: u32, max: Option<u32>) -> Limits[src]Creates a new set of limits with the minimum and maximum both specified.
+pub fn at_least(min: u32) -> Limits[src]Creates a new Limits with the min specified and no maximum specified.
pub fn min(&self) -> u32[src]Returns the minimum amount for these limits.
+pub fn max(&self) -> Option<u32>[src]Returns the maximum amount for these limits, if specified.
+impl RefUnwindSafe for Limitsimpl Send for Limitsimpl Sync for Limitsimpl Unpin for Limitsimpl UnwindSafe for Limitsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly linear memory.
+WebAssembly memories represent a contiguous array of bytes that have a size +that is always a multiple of the WebAssembly page size, currently 64 +kilobytes.
+WebAssembly memory is used for global data, statics in C/C++/Rust, shadow +stack memory, etc. Accessing wasm memory is generally quite fast!
+Memory and CloneMemories are internally reference counted so you can clone a Memory. The
+cloning process only performs a shallow clone, so two cloned Memory
+instances are equivalent in their functionality.
Memory and threadsIt is intended that Memory is safe to share between threads. At this time
+this is not implemented in wasmtime, however. This is planned to be
+implemented though!
impl Memory[src]pub fn new(store: &Store, ty: MemoryType) -> Memory[src]Creates a new WebAssembly memory given the configuration of ty.
The store argument is a general location for cache information, and
+otherwise the memory will immediately be allocated according to the
+type's configuration. All WebAssembly memory is initialized to zero.
pub fn ty(&self) -> &MemoryType[src]Returns the underlying type of this memory.
+pub unsafe fn data_unchecked(&self) -> &[u8][src]Returns this memory as a slice view that can be read natively in Rust.
+This is an unsafe operation because there is no guarantee that the +following operations do not happen concurrently while the slice is in +use:
+Extreme care need be taken when the data of a Memory is read. The
+above invariants all need to be upheld at a bare minimum, and in
+general you'll need to ensure that while you're looking at slice you're
+the only one who can possibly look at the slice and read/write it.
Be sure to keep in mind that Memory is reference counted, meaning
+that there may be other users of this Memory instance elsewhere in
+your program. Additionally Memory can be shared and used in any number
+of wasm instances, so calling any wasm code should be considered
+dangerous while you're holding a slice of memory.
pub unsafe fn data_unchecked_mut(&self) -> &mut [u8][src]Returns this memory as a slice view that can be read and written +natively in Rust.
+All of the same safety caveats of Memory::data_unchecked apply
+here, doubly so because this is returning a mutable slice! As a
+double-extra reminder, remember that Memory is reference counted, so
+you can very easily acquire two mutable slices by simply calling this
+function twice. Extreme caution should be used when using this method,
+and in general you probably want to result to unsafe accessors and the
+data methods below.
pub fn data_ptr(&self) -> *mut u8[src]Returns the base pointer, in the host's address space, that the memory +is located at.
+When reading and manipulating memory be sure to read up on the caveats
+of Memory::data_unchecked to make sure that you can safely
+read/write the memory.
pub fn data_size(&self) -> usize[src]Returns the byte length of this memory.
+The returned value will be a multiple of the wasm page size, 64k.
+pub fn size(&self) -> u32[src]Returns the size, in pages, of this wasm memory.
+pub fn grow(&self, delta: u32) -> Result<u32>[src]Grows this WebAssembly memory by delta pages.
This will attempt to add delta more pages of memory on to the end of
+this Memory instance. If successful this may relocate the memory and
+cause Memory::data_ptr to return a new value. Additionally previous
+slices into this memory may no longer be valid.
On success returns the number of pages this memory previously had +before the growth succeeded.
+Returns an error if memory could not be grown, for example if it exceeds +the maximum limits of this memory.
+impl !RefUnwindSafe for Memoryimpl !Send for Memoryimpl !Sync for Memoryimpl Unpin for Memoryimpl !UnwindSafe for Memoryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A descriptor for a WebAssembly memory type.
+Memories are described in units of pages (64KB) and represent contiguous +chunks of addressable memory.
+impl MemoryType[src]pub fn new(limits: Limits) -> MemoryType[src]Creates a new descriptor for a WebAssembly memory given the specified +limits of the memory.
+pub fn limits(&self) -> &Limits[src]Returns the limits (in pages) that are configured for this memory.
+impl Clone for MemoryType[src]fn clone(&self) -> MemoryType[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for MemoryType[src]impl RefUnwindSafe for MemoryTypeimpl Send for MemoryTypeimpl Sync for MemoryTypeimpl Unpin for MemoryTypeimpl UnwindSafe for MemoryTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A compiled WebAssembly module, ready to be instantiated.
+A Module is a compiled in-memory representation of an input WebAssembly
+binary. A Module is then used to create an Instance
+through an instantiation process. You cannot call functions or fetch
+globals, for example, on a Module because it's purely a code
+representation. Instead you'll need to create an
+Instance to interact with the wasm module.
CloneUsing clone on a Module is a cheap operation. It will not create an
+entirely new module, but rather just a new reference to the existing module.
+In other words it's a shallow copy, not a deep copy.
impl Module[src]pub fn new(store: &Store, bytes: impl AsRef<[u8]>) -> Result<Module>[src]Creates a new WebAssembly Module from the given in-memory bytes.
The bytes provided must be in one of two formats:
wat feature of this
+crate is enabled. If this is supplied then the text format will be
+parsed before validation. Note that the wat feature is enabled by
+default.The data for the wasm module must be loaded in-memory if it's present +elsewhere, for example on disk. This requires that the entire binary is +loaded into memory all at once, this API does not support streaming +compilation of a module.
+The WebAssembly binary will be decoded and validated. It will also be
+compiled according to the configuration of the provided store and
+cached in this type.
The provided store is a global cache for compiled resources as well as
+configuration for what wasm features are enabled. It's recommended to
+share a store among modules if possible.
This function may fail and return an error. Errors may include +situations such as:
+storewat feature is enabled and the input is text, then it may be
+rejected if it fails to parse.The error returned should contain full information about why module +creation failed if one is returned.
+pub fn new_with_name(
store: &Store,
bytes: impl AsRef<[u8]>,
name: &str
) -> Result<Module>[src]Creates a new WebAssembly Module from the given in-memory binary
+data. The provided name will be used in traps/backtrace details.
See Module::new for other details.
pub fn from_file(store: &Store, file: impl AsRef<Path>) -> Result<Module>[src]Creates a new WebAssembly Module from the contents of the given
+file on disk.
This is a convenience function that will read the file provided and
+pass the bytes to the Module::new function. For more information
+see Module::new
pub fn from_binary(store: &Store, binary: &[u8]) -> Result<Module>[src]Creates a new WebAssembly Module from the given in-memory binary
+data.
This is similar to Module::new except that it requires that the
+binary input is a WebAssembly binary, the text format is not supported
+by this function. It's generally recommended to use Module::new,
+but if it's required to not support the text format this function can be
+used instead.
pub unsafe fn from_binary_unchecked(
store: &Store,
binary: &[u8]
) -> Result<Module>[src]Creates a new WebAssembly Module from the given in-memory binary
+data, skipping validation and asserting that binary is a valid
+WebAssembly module.
This function is the same as Module::new except that it skips the
+call to Module::validate and it does not support the text format of
+WebAssembly. The WebAssembly binary is not validated for
+correctness and it is simply assumed as valid.
For more information about creation of a module and the store argument
+see the documentation of Module::new.
This function is unsafe due to the unchecked assumption that the input
+binary is valid. If the binary is not actually a valid wasm binary it
+may cause invalid machine code to get generated, cause panics, etc.
It is only safe to call this method if Module::validate succeeds on
+the same arguments passed to this function.
This function may fail for many of the same reasons as Module::new.
+While this assumes that the binary is valid it still needs to actually
+be somewhat valid for decoding purposes, and the basics of decoding can
+still fail.
pub fn validate(store: &Store, binary: &[u8]) -> Result<()>[src]Validates binary input data as a WebAssembly binary given the
+configuration in store.
This function will perform a speedy validation of the binary input
+WebAssembly module (which is in binary form, the text format
+is not accepted by this function) and return either Ok or Err
+depending on the results of validation. The store argument indicates
+configuration for WebAssembly features, for example, which are used to
+indicate what should be valid and what shouldn't be.
Validation automatically happens as part of Module::new, but is a
+requirement for [Module::new_unchecked] to be safe.
If validation fails for any reason (type check error, usage of a feature +that wasn't enabled, etc) then an error with a description of the +validation issue will be returned.
+pub fn name(&self) -> Option<&str>[src]Returns identifier/name that this Module has. This name
+is used in traps/backtrace details.
pub fn imports(&self) -> &[ImportType][src]Returns the list of imports that this Module has and must be
+satisfied.
pub fn exports(&self) -> &[ExportType][src]Returns the list of exports that this Module has and will be
+available after instantiation.
pub fn store(&self) -> &Store[src]impl !RefUnwindSafe for Moduleimpl !Send for Moduleimpl !Sync for Moduleimpl Unpin for Moduleimpl !UnwindSafe for Moduleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A Store is a shared cache of information between WebAssembly modules.
Each Module is compiled into a Store and a Store is associated with an
+Engine. You'll use a Store to attach to a number of global items in
+the production of various items for wasm modules.
CloneUsing clone on a Store is a cheap operation. It will not create an
+entirely new store, but rather just a new reference to the existing object.
+In other words it's a shallow copy, not a deep copy.
DefaultYou can create a store with default configuration settings using
+Store::default(). This will create a brand new Engine with default
+ocnfiguration (see Config for more information).
impl Store[src]pub fn new(engine: &Engine) -> Store[src]Creates a new store to be associated with the given Engine.
pub fn engine(&self) -> &Engine[src]Returns the Engine that this store is associated with.
pub fn same(a: &Store, b: &Store) -> bool[src]Returns whether the stores a and b refer to the same underlying
+Store.
Because the Store type is reference counted multiple clones may point
+to the same underlying storage, and this method can be used to determine
+whether two stores are indeed the same.
impl !RefUnwindSafe for Storeimpl !Send for Storeimpl !Sync for Storeimpl Unpin for Storeimpl !UnwindSafe for Storeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly table, or an array of values.
Like Memory a table is an indexed array of values, but unlike Memory
+it's an array of WebAssembly values rather than bytes. One of the most
+common usages of a table is a function table for wasm modules, where each
+element has the Func type.
Tables, like globals, are not threadsafe and can only be used on one thread. +Tables can be grown in size and each element can be read/written.
+Table and CloneTables are internally reference counted so you can clone a Table. The
+cloning process only performs a shallow clone, so two cloned Table
+instances are equivalent in their functionality.
impl Table[src]pub fn new(store: &Store, ty: TableType, init: Val) -> Result<Table>[src]Creates a new Table with the given parameters.
store - a global cache to store information inty - the type of this table, containing both the element type as
+well as the initial size and maximum size, if any.init - the initial value to fill all table entries with, if the
+table starts with an initial size.Returns an error if init does not match the element type of the table.
pub fn ty(&self) -> &TableType[src]Returns the underlying type of this table, including its element type as +well as the maximum/minimum lower bounds.
+pub fn get(&self, index: u32) -> Option<Val>[src]Returns the table element value at index.
Returns None if index is out of bounds.
pub fn set(&self, index: u32, val: Val) -> Result<()>[src]Writes the val provided into index within this table.
Returns an error if index is out of bounds or if val does not have
+the right type to be stored in this table.
pub fn size(&self) -> u32[src]Returns the current size of this table.
+pub fn grow(&self, delta: u32, init: Val) -> Result<u32>[src]Grows the size of this table by delta more elements, initialization
+all new elements to init.
Returns an error if the table cannot be grown by delta, for example
+if it would cause the table to exceed its maximum size. Also returns an
+error if init is not of the right type.
impl !RefUnwindSafe for Tableimpl !Send for Tableimpl !Sync for Tableimpl Unpin for Tableimpl !UnwindSafe for Tableimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A descriptor for a table in a WebAssembly module.
+Tables are contiguous chunks of a specific element, typically a funcref or
+an anyref. The most common use for tables is a function table through
+which call_indirect can invoke other functions.
impl TableType[src]pub fn new(element: ValType, limits: Limits) -> TableType[src]Creates a new table descriptor which will contain the specified
+element and have the limits applied to its length.
pub fn element(&self) -> &ValType[src]Returns the element value type of this table.
+pub fn limits(&self) -> &Limits[src]Returns the limits, in units of elements, of this table.
+impl RefUnwindSafe for TableTypeimpl Send for TableTypeimpl Sync for TableTypeimpl Unpin for TableTypeimpl UnwindSafe for TableTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A struct representing an aborted instruction execution, with a message +indicating the cause.
+impl Trap[src]pub fn new<I: Into<String>>(message: I) -> Self[src]Creates a new Trap with message.
+let trap = wasmtime::Trap::new("unexpected error"); +assert_eq!("unexpected error", trap.message());
pub fn message(&self) -> &str[src]Returns a reference the message stored in Trap.
pub fn trace(&self) -> &[FrameInfo][src]Returns a list of function frames in WebAssembly code that led to this +trap happening.
+impl RefUnwindSafe for Trapimpl Send for Trapimpl Sync for Trapimpl Unpin for Trapimpl UnwindSafe for Trapimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A trait representing a function that can be imported and called from inside +WebAssembly.
++use wasmtime::Val; + +struct TimesTwo; + +impl wasmtime::Callable for TimesTwo { + fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), wasmtime::Trap> { + let mut value = params[0].unwrap_i32(); + value *= 2; + results[0] = value.into(); + + Ok(()) + } +} + +// Simple module that imports our host function ("times_two") and re-exports +// it as "run". +let wat = r#" + (module + (func $times_two (import "" "times_two") (param i32) (result i32)) + (func + (export "run") + (param i32) + (result i32) + (local.get 0) + (call $times_two)) + ) +"#; + +// Initialise environment and our module. +let store = wasmtime::Store::default(); +let module = wasmtime::Module::new(&store, wat)?; + +// Define the type of the function we're going to call. +let times_two_type = wasmtime::FuncType::new( + // Parameters + Box::new([wasmtime::ValType::I32]), + // Results + Box::new([wasmtime::ValType::I32]) +); + +// Build a reference to the "times_two" function that can be used. +let times_two_function = + wasmtime::Func::new(&store, times_two_type, std::rc::Rc::new(TimesTwo)); + +// Create module instance that imports our function +let instance = wasmtime::Instance::new( + &module, + &[times_two_function.into()] +)?; + +// Get "run" function from the exports. +let run_function = instance.exports()[0].func().unwrap(); + +// Borrow and call "run". Returning any error message from Wasm as a string. +let original = 5i32; +let results = run_function + .call(&[original.into()]) + .map_err(|trap| trap.to_string())?; + +// Compare that the results returned matches what we expect. +assert_eq!(original * 2, results[0].unwrap_i32());
fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), Trap>What is called when the function is invoked in WebAssembly.
+params is an immutable list of parameters provided to the function.
+results is mutable list of results to be potentially set by your
+function. Produces a Trap if the function encounters any errors.
fn finalize(&mut self)A trait implemented for types which can be returned from closures passed to
+Func::wrap1 and friends.
This trait should not be implemented by user types. This trait may change at +any time internally. The types which implement this trait, however, are +stable over time.
+For more information see Func::wrap1
impl<T: WasmTy> WasmRet for Result<T, Trap>[src]type Abi = T::Abifn push(dst: &mut Vec<ValType>)[src]fn matches(tys: impl Iterator<Item = ValType>) -> bool[src]fn into_abi(self) -> Self::Abi[src]A trait implemented for types which can be arguments to closures passed to
+Func::wrap1 and friends.
This trait should not be implemented by user types. This trait may change at +any time internally. The types which implement this trait, however, are +stable over time.
+For more information see Func::wrap1
impl WasmTy for ()[src]type Abi = ()fn push(_dst: &mut Vec<ValType>)[src]fn matches(_tys: impl Iterator<Item = ValType>) -> bool[src]fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self[src]fn into_abi(self) -> Self::Abi[src]impl WasmTy for i32[src]type Abi = Selffn push(dst: &mut Vec<ValType>)[src]fn matches(tys: impl Iterator<Item = ValType>) -> bool[src]fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self[src]fn into_abi(self) -> Self::Abi[src]impl WasmTy for i64[src]type Abi = Selffn push(dst: &mut Vec<ValType>)[src]fn matches(tys: impl Iterator<Item = ValType>) -> bool[src]fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self[src]fn into_abi(self) -> Self::Abi[src]impl WasmTy for f32[src]type Abi = Selffn push(dst: &mut Vec<ValType>)[src]fn matches(tys: impl Iterator<Item = ValType>) -> bool[src]fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self[src]fn into_abi(self) -> Self::Abi[src]impl WasmTy for f64[src]type Abi = Selffn push(dst: &mut Vec<ValType>)[src]fn matches(tys: impl Iterator<Item = ValType>) -> bool[src]fn from_abi(_vmctx: *mut VMContext, abi: Self::Abi) -> Self[src]fn into_abi(self) -> Self::Abi[src]Redirecting to ../../wasmtime/struct.Trap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/enum.ExternType.html b/api/wasmtime/types/enum.ExternType.html new file mode 100644 index 000000000000..19c2ad8a3651 --- /dev/null +++ b/api/wasmtime/types/enum.ExternType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.ExternType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/enum.Mutability.html b/api/wasmtime/types/enum.Mutability.html new file mode 100644 index 000000000000..239aeee546f5 --- /dev/null +++ b/api/wasmtime/types/enum.Mutability.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.Mutability.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/enum.ValType.html b/api/wasmtime/types/enum.ValType.html new file mode 100644 index 000000000000..85e7bb308366 --- /dev/null +++ b/api/wasmtime/types/enum.ValType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/enum.ValType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.ExportType.html b/api/wasmtime/types/struct.ExportType.html new file mode 100644 index 000000000000..f104a9256f7f --- /dev/null +++ b/api/wasmtime/types/struct.ExportType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.ExportType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.FuncType.html b/api/wasmtime/types/struct.FuncType.html new file mode 100644 index 000000000000..edf108c843f4 --- /dev/null +++ b/api/wasmtime/types/struct.FuncType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.FuncType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.GlobalType.html b/api/wasmtime/types/struct.GlobalType.html new file mode 100644 index 000000000000..581443959f76 --- /dev/null +++ b/api/wasmtime/types/struct.GlobalType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.GlobalType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.ImportType.html b/api/wasmtime/types/struct.ImportType.html new file mode 100644 index 000000000000..2ffbcaaf61c1 --- /dev/null +++ b/api/wasmtime/types/struct.ImportType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.ImportType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.Limits.html b/api/wasmtime/types/struct.Limits.html new file mode 100644 index 000000000000..0fec41a939ac --- /dev/null +++ b/api/wasmtime/types/struct.Limits.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.Limits.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.MemoryType.html b/api/wasmtime/types/struct.MemoryType.html new file mode 100644 index 000000000000..b95737113d28 --- /dev/null +++ b/api/wasmtime/types/struct.MemoryType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.MemoryType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/types/struct.TableType.html b/api/wasmtime/types/struct.TableType.html new file mode 100644 index 000000000000..47eceab36c61 --- /dev/null +++ b/api/wasmtime/types/struct.TableType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime/struct.TableType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime/unix/index.html b/api/wasmtime/unix/index.html new file mode 100644 index 000000000000..18f03beb9e5c --- /dev/null +++ b/api/wasmtime/unix/index.html @@ -0,0 +1,11 @@ +Unix-specific extension for the wasmtime crate.
This module is only available on Unix targets, for example Linux and macOS.
+It is not available on Windows, for example. Note that the import path for
+this module is wasmtime::unix::..., which is intended to emphasize that it
+is platform-specific.
The traits contained in this module are intended to extend various types
+throughout the wasmtime crate with extra functionality that's only
+available on Unix.
| InstanceExt | Extensions for the |
Extensions for the Instance type only available on Unix.
unsafe fn set_signal_handler<H>(&self, handler: H) where
H: 'static + Fn(c_int, *const siginfo_t, *const c_void) -> bool, The signal handler must be +async-signal-safe.
+Redirecting to ../../wasmtime/enum.Val.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/all.html b/api/wasmtime_debug/all.html new file mode 100644 index 000000000000..f6b226266ed9 --- /dev/null +++ b/api/wasmtime_debug/all.html @@ -0,0 +1,3 @@ +PhysicalAddress(u64)impl RefUnwindSafe for ResolvedSymbolimpl Send for ResolvedSymbolimpl Sync for ResolvedSymbolimpl Unpin for ResolvedSymbolimpl UnwindSafe for ResolvedSymbolimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn emit_debugsections(
obj: &mut Artifact,
vmctx_info: &ModuleVmctxInfo,
target_config: TargetFrontendConfig,
debuginfo_data: &DebugInfoData,
at: &ModuleAddressMap,
ranges: &ValueLabelsRanges
) -> Result<(), Error>
pub fn emit_debugsections_image(
triple: Triple,
target_config: TargetFrontendConfig,
debuginfo_data: &DebugInfoData,
vmctx_info: &ModuleVmctxInfo,
at: &ModuleAddressMap,
ranges: &ValueLabelsRanges,
funcs: &[(*const u8, usize)]
) -> Result<Vec<u8>, Error>
pub fn emit_dwarf(
artifact: &mut Artifact,
dwarf: Dwarf,
symbol_resolver: &dyn SymbolResolver
) -> Result<()>
pub fn read_debuginfo(data: &[u8]) -> DebugInfoData
pub fn transform_dwarf(
target_config: TargetFrontendConfig,
di: &DebugInfoData,
at: &ModuleAddressMap,
vmctx_info: &ModuleVmctxInfo,
ranges: &ValueLabelsRanges
) -> Result<Dwarf, Error>
Debug utils for WebAssembly using Cranelift.
+| DebugInfoData | |
| WasmFileInfo |
| ResolvedSymbol |
| SymbolResolver |
| emit_debugsections | |
| emit_debugsections_image | |
| emit_dwarf | |
| read_debuginfo | |
| transform_dwarf |
Redirecting to ../../wasmtime_debug/fn.read_debuginfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/read_debuginfo/struct.DebugInfoData.html b/api/wasmtime_debug/read_debuginfo/struct.DebugInfoData.html new file mode 100644 index 000000000000..92103c2c51d7 --- /dev/null +++ b/api/wasmtime_debug/read_debuginfo/struct.DebugInfoData.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_debug/struct.DebugInfoData.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/read_debuginfo/struct.WasmFileInfo.html b/api/wasmtime_debug/read_debuginfo/struct.WasmFileInfo.html new file mode 100644 index 000000000000..ffcb7db7b29d --- /dev/null +++ b/api/wasmtime_debug/read_debuginfo/struct.WasmFileInfo.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_debug/struct.WasmFileInfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/sidebar-items.js b/api/wasmtime_debug/sidebar-items.js new file mode 100644 index 000000000000..9ae5e3cffb55 --- /dev/null +++ b/api/wasmtime_debug/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"enum":[["ResolvedSymbol",""]],"fn":[["emit_debugsections",""],["emit_debugsections_image",""],["emit_dwarf",""],["read_debuginfo",""],["transform_dwarf",""]],"struct":[["DebugInfoData",""],["WasmFileInfo",""]],"trait":[["SymbolResolver",""]]}); \ No newline at end of file diff --git a/api/wasmtime_debug/struct.DebugInfoData.html b/api/wasmtime_debug/struct.DebugInfoData.html new file mode 100644 index 000000000000..3167e0ad0c28 --- /dev/null +++ b/api/wasmtime_debug/struct.DebugInfoData.html @@ -0,0 +1,17 @@ +dwarf: Dwarf<EndianSlice<'a, LittleEndian>>name_section: Option<NameSection>wasm_file: WasmFileInfoimpl<'a> RefUnwindSafe for DebugInfoData<'a>impl<'a> Send for DebugInfoData<'a>impl<'a> Sync for DebugInfoData<'a>impl<'a> Unpin for DebugInfoData<'a>impl<'a> UnwindSafe for DebugInfoData<'a>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]path: Option<PathBuf>code_section_offset: u64funcs: Box<[FunctionMetadata]>impl RefUnwindSafe for WasmFileInfoimpl Send for WasmFileInfoimpl Sync for WasmFileInfoimpl Unpin for WasmFileInfoimpl UnwindSafe for WasmFileInfoimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]fn resolve_symbol(&self, symbol: usize, addend: i64) -> ResolvedSymbolRedirecting to ../../wasmtime_debug/fn.transform_dwarf.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/write_debuginfo/enum.ResolvedSymbol.html b/api/wasmtime_debug/write_debuginfo/enum.ResolvedSymbol.html new file mode 100644 index 000000000000..de92e395b8b5 --- /dev/null +++ b/api/wasmtime_debug/write_debuginfo/enum.ResolvedSymbol.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_debug/enum.ResolvedSymbol.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/write_debuginfo/fn.emit_dwarf.html b/api/wasmtime_debug/write_debuginfo/fn.emit_dwarf.html new file mode 100644 index 000000000000..e629536edba8 --- /dev/null +++ b/api/wasmtime_debug/write_debuginfo/fn.emit_dwarf.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_debug/fn.emit_dwarf.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_debug/write_debuginfo/trait.SymbolResolver.html b/api/wasmtime_debug/write_debuginfo/trait.SymbolResolver.html new file mode 100644 index 000000000000..778ef6582663 --- /dev/null +++ b/api/wasmtime_debug/write_debuginfo/trait.SymbolResolver.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_debug/trait.SymbolResolver.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/enum.ModuleMemoryOffset.html b/api/wasmtime_environ/address_map/enum.ModuleMemoryOffset.html new file mode 100644 index 000000000000..77178c99f567 --- /dev/null +++ b/api/wasmtime_environ/address_map/enum.ModuleMemoryOffset.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.ModuleMemoryOffset.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/struct.FunctionAddressMap.html b/api/wasmtime_environ/address_map/struct.FunctionAddressMap.html new file mode 100644 index 000000000000..809c0931fbdc --- /dev/null +++ b/api/wasmtime_environ/address_map/struct.FunctionAddressMap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.FunctionAddressMap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/struct.InstructionAddressMap.html b/api/wasmtime_environ/address_map/struct.InstructionAddressMap.html new file mode 100644 index 000000000000..63f600f5040a --- /dev/null +++ b/api/wasmtime_environ/address_map/struct.InstructionAddressMap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.InstructionAddressMap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/struct.ModuleVmctxInfo.html b/api/wasmtime_environ/address_map/struct.ModuleVmctxInfo.html new file mode 100644 index 000000000000..05e2cbb555c8 --- /dev/null +++ b/api/wasmtime_environ/address_map/struct.ModuleVmctxInfo.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.ModuleVmctxInfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/type.ModuleAddressMap.html b/api/wasmtime_environ/address_map/type.ModuleAddressMap.html new file mode 100644 index 000000000000..32031225b3f6 --- /dev/null +++ b/api/wasmtime_environ/address_map/type.ModuleAddressMap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/type.ModuleAddressMap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/address_map/type.ValueLabelsRanges.html b/api/wasmtime_environ/address_map/type.ValueLabelsRanges.html new file mode 100644 index 000000000000..992ee64ff507 --- /dev/null +++ b/api/wasmtime_environ/address_map/type.ValueLabelsRanges.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/type.ValueLabelsRanges.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/all.html b/api/wasmtime_environ/all.html new file mode 100644 index 000000000000..fac9fdc798af --- /dev/null +++ b/api/wasmtime_environ/all.html @@ -0,0 +1,3 @@ +Redirecting to ../../../wasmtime_environ/fn.cache_create_new_config.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/cache/config/struct.CacheConfig.html b/api/wasmtime_environ/cache/config/struct.CacheConfig.html new file mode 100644 index 000000000000..d7efbf3b41f0 --- /dev/null +++ b/api/wasmtime_environ/cache/config/struct.CacheConfig.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/struct.CacheConfig.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/enum.CompileError.html b/api/wasmtime_environ/compilation/enum.CompileError.html new file mode 100644 index 000000000000..675e6ec7b58f --- /dev/null +++ b/api/wasmtime_environ/compilation/enum.CompileError.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.CompileError.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/enum.CompiledFunctionUnwindInfo.html b/api/wasmtime_environ/compilation/enum.CompiledFunctionUnwindInfo.html new file mode 100644 index 000000000000..9e3c5386f433 --- /dev/null +++ b/api/wasmtime_environ/compilation/enum.CompiledFunctionUnwindInfo.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.CompiledFunctionUnwindInfo.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/enum.RelocationTarget.html b/api/wasmtime_environ/compilation/enum.RelocationTarget.html new file mode 100644 index 000000000000..7bd2ff6a0b2c --- /dev/null +++ b/api/wasmtime_environ/compilation/enum.RelocationTarget.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.RelocationTarget.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/struct.Compilation.html b/api/wasmtime_environ/compilation/struct.Compilation.html new file mode 100644 index 000000000000..acf1aaa24e36 --- /dev/null +++ b/api/wasmtime_environ/compilation/struct.Compilation.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.Compilation.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/struct.CompiledFunction.html b/api/wasmtime_environ/compilation/struct.CompiledFunction.html new file mode 100644 index 000000000000..a2d90c71b62c --- /dev/null +++ b/api/wasmtime_environ/compilation/struct.CompiledFunction.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.CompiledFunction.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/struct.CompiledFunctionUnwindInfoReloc.html b/api/wasmtime_environ/compilation/struct.CompiledFunctionUnwindInfoReloc.html new file mode 100644 index 000000000000..2dbd31b7950e --- /dev/null +++ b/api/wasmtime_environ/compilation/struct.CompiledFunctionUnwindInfoReloc.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.CompiledFunctionUnwindInfoReloc.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/struct.Relocation.html b/api/wasmtime_environ/compilation/struct.Relocation.html new file mode 100644 index 000000000000..0d3aae1f4764 --- /dev/null +++ b/api/wasmtime_environ/compilation/struct.Relocation.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.Relocation.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/struct.TrapInformation.html b/api/wasmtime_environ/compilation/struct.TrapInformation.html new file mode 100644 index 000000000000..abf952527a68 --- /dev/null +++ b/api/wasmtime_environ/compilation/struct.TrapInformation.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.TrapInformation.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/trait.Compiler.html b/api/wasmtime_environ/compilation/trait.Compiler.html new file mode 100644 index 000000000000..5787685f7fff --- /dev/null +++ b/api/wasmtime_environ/compilation/trait.Compiler.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/trait.Compiler.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/type.Relocations.html b/api/wasmtime_environ/compilation/type.Relocations.html new file mode 100644 index 000000000000..290db1900b6a --- /dev/null +++ b/api/wasmtime_environ/compilation/type.Relocations.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/type.Relocations.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/compilation/type.Traps.html b/api/wasmtime_environ/compilation/type.Traps.html new file mode 100644 index 000000000000..61a926c8dabd --- /dev/null +++ b/api/wasmtime_environ/compilation/type.Traps.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/type.Traps.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/constant.VERSION.html b/api/wasmtime_environ/constant.VERSION.html new file mode 100644 index 000000000000..58fff61e05f7 --- /dev/null +++ b/api/wasmtime_environ/constant.VERSION.html @@ -0,0 +1,2 @@ +pub const VERSION: &str = env!("CARGO_PKG_VERSION");
Version number of this crate.
+pub const WASM_MAX_PAGES: u32 = 0x10000;
The number of pages we can have before we run out of byte index space.
+pub const WASM_PAGE_SIZE: u32 = 0x10000;
WebAssembly page sizes are defined to be 64KiB.
+Support for compiling with Cranelift.
+| Cranelift | A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR, +optimizing it and then translating to assembly. + |
| RelocSink | Implementation of a relocation sink that just saves all the information for later + |
A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR, +optimizing it and then translating to assembly.
+impl Compiler for Cranelift[src]fn compile_module<'data, 'module>(
module: &'module Module,
module_translation: &ModuleTranslationState,
function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
isa: &dyn TargetIsa,
generate_debug_info: bool,
cache_config: &CacheConfig
) -> Result<(Compilation, Relocations, ModuleAddressMap, ValueLabelsRanges, PrimaryMap<DefinedFuncIndex, StackSlots>, Traps), CompileError>[src]Compile the module using Cranelift, producing a compilation result with +associated relocations.
+impl RefUnwindSafe for Craneliftimpl Send for Craneliftimpl Sync for Craneliftimpl Unpin for Craneliftimpl UnwindSafe for Craneliftimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Implementation of a relocation sink that just saves all the information for later
+func_relocs: Vec<Relocation>Relocations recorded for the function.
+impl RelocSink[src]impl RelocSink for RelocSink[src]fn reloc_block(
&mut self,
_offset: CodeOffset,
_reloc: Reloc,
_block_offset: CodeOffset
)[src]fn reloc_external(
&mut self,
offset: CodeOffset,
reloc: Reloc,
name: &ExternalName,
addend: Addend
)[src]fn reloc_constant(
&mut self,
_code_offset: CodeOffset,
_reloc: Reloc,
_constant_offset: ConstantOffset
)[src]fn reloc_jt(&mut self, offset: CodeOffset, reloc: Reloc, jt: JumpTable)[src]impl RefUnwindSafe for RelocSinkimpl Send for RelocSinkimpl Sync for RelocSinkimpl Unpin for RelocSinkimpl UnwindSafe for RelocSinkimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../../wasmtime_environ/entity/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/entity/struct.BoxedSlice.html b/api/wasmtime_environ/data_structures/entity/struct.BoxedSlice.html new file mode 100644 index 000000000000..6d246dc50d24 --- /dev/null +++ b/api/wasmtime_environ/data_structures/entity/struct.BoxedSlice.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/entity/struct.BoxedSlice.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/entity/struct.PrimaryMap.html b/api/wasmtime_environ/data_structures/entity/struct.PrimaryMap.html new file mode 100644 index 000000000000..78fc6dbe8e57 --- /dev/null +++ b/api/wasmtime_environ/data_structures/entity/struct.PrimaryMap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/entity/struct.PrimaryMap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/entity/trait.EntityRef.html b/api/wasmtime_environ/data_structures/entity/trait.EntityRef.html new file mode 100644 index 000000000000..4a7fa8a3bb0d --- /dev/null +++ b/api/wasmtime_environ/data_structures/entity/trait.EntityRef.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/entity/trait.EntityRef.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/enum.ArgumentPurpose.html b/api/wasmtime_environ/data_structures/ir/enum.ArgumentPurpose.html new file mode 100644 index 000000000000..4c714c7c1250 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/enum.ArgumentPurpose.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/enum.ArgumentPurpose.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/enum.TrapCode.html b/api/wasmtime_environ/data_structures/ir/enum.TrapCode.html new file mode 100644 index 000000000000..8616dbb6585b --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/enum.TrapCode.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/enum.TrapCode.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/enum.ValueLoc.html b/api/wasmtime_environ/data_structures/ir/enum.ValueLoc.html new file mode 100644 index 000000000000..2a2de1429e5c --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/enum.ValueLoc.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/enum.ValueLoc.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/index.html b/api/wasmtime_environ/data_structures/ir/index.html new file mode 100644 index 000000000000..1bda21920b8f --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/index.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.AbiParam.html b/api/wasmtime_environ/data_structures/ir/struct.AbiParam.html new file mode 100644 index 000000000000..c9200e949aac --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.AbiParam.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.AbiParam.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.Signature.html b/api/wasmtime_environ/data_structures/ir/struct.Signature.html new file mode 100644 index 000000000000..5cd5b7f45155 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.Signature.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.Signature.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.SourceLoc.html b/api/wasmtime_environ/data_structures/ir/struct.SourceLoc.html new file mode 100644 index 000000000000..f0cc981e3565 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.SourceLoc.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.SourceLoc.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.StackSlots.html b/api/wasmtime_environ/data_structures/ir/struct.StackSlots.html new file mode 100644 index 000000000000..96780dd74d93 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.StackSlots.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.StackSlots.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.Type.html b/api/wasmtime_environ/data_structures/ir/struct.Type.html new file mode 100644 index 000000000000..71b757fc8426 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.Type.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.Type.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/struct.ValueLabel.html b/api/wasmtime_environ/data_structures/ir/struct.ValueLabel.html new file mode 100644 index 000000000000..bf3ec81debe4 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/struct.ValueLabel.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/struct.ValueLabel.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/type.ValueLabelsRanges.html b/api/wasmtime_environ/data_structures/ir/type.ValueLabelsRanges.html new file mode 100644 index 000000000000..ec5724f35f24 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/type.ValueLabelsRanges.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/ir/type.ValueLabelsRanges.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B1.html b/api/wasmtime_environ/data_structures/ir/types/constant.B1.html new file mode 100644 index 000000000000..f37774e058cb --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B1.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B1.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B128.html b/api/wasmtime_environ/data_structures/ir/types/constant.B128.html new file mode 100644 index 000000000000..68323af13cd8 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B128.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B128.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B128X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.B128X2.html new file mode 100644 index 000000000000..0e8109dbded3 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B128X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B128X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B128X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.B128X4.html new file mode 100644 index 000000000000..350c49cf8908 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B128X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B128X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B16.html b/api/wasmtime_environ/data_structures/ir/types/constant.B16.html new file mode 100644 index 000000000000..daf10d8f93ed --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B16X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.B16X16.html new file mode 100644 index 000000000000..7b06d79d61ee --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B16X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B16X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B16X32.html b/api/wasmtime_environ/data_structures/ir/types/constant.B16X32.html new file mode 100644 index 000000000000..b1e5b7b313d0 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B16X32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B16X32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B16X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.B16X4.html new file mode 100644 index 000000000000..1638d3d4faa8 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B16X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B16X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B16X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.B16X8.html new file mode 100644 index 000000000000..a8570207eeda --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B16X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B16X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B32.html b/api/wasmtime_environ/data_structures/ir/types/constant.B32.html new file mode 100644 index 000000000000..f42d30f4326f --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B32X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.B32X16.html new file mode 100644 index 000000000000..8fe1354cdb9f --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B32X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B32X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B32X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.B32X2.html new file mode 100644 index 000000000000..a74b8f64b78c --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B32X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B32X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B32X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.B32X4.html new file mode 100644 index 000000000000..0fb6d30fc567 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B32X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B32X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B32X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.B32X8.html new file mode 100644 index 000000000000..be1eafb42344 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B32X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B32X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B64.html b/api/wasmtime_environ/data_structures/ir/types/constant.B64.html new file mode 100644 index 000000000000..22d0a9ac28c5 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B64X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.B64X2.html new file mode 100644 index 000000000000..7b1e587d1c56 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B64X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B64X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B64X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.B64X4.html new file mode 100644 index 000000000000..3ac35ff3b736 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B64X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B64X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B64X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.B64X8.html new file mode 100644 index 000000000000..a299370a9a07 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B64X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B64X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B8.html b/api/wasmtime_environ/data_structures/ir/types/constant.B8.html new file mode 100644 index 000000000000..a45cea47f524 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B8X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.B8X16.html new file mode 100644 index 000000000000..f3d0cefe409d --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B8X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B8X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B8X32.html b/api/wasmtime_environ/data_structures/ir/types/constant.B8X32.html new file mode 100644 index 000000000000..afd3aa39def8 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B8X32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B8X32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B8X64.html b/api/wasmtime_environ/data_structures/ir/types/constant.B8X64.html new file mode 100644 index 000000000000..18f881e186c4 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B8X64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B8X64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.B8X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.B8X8.html new file mode 100644 index 000000000000..966eb98e0808 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.B8X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.B8X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F32.html b/api/wasmtime_environ/data_structures/ir/types/constant.F32.html new file mode 100644 index 000000000000..112479ab5305 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F32X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.F32X16.html new file mode 100644 index 000000000000..d7e0ce181b65 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F32X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F32X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F32X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.F32X2.html new file mode 100644 index 000000000000..b4b9ee246610 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F32X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F32X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F32X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.F32X4.html new file mode 100644 index 000000000000..37012a8f4cb9 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F32X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F32X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F32X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.F32X8.html new file mode 100644 index 000000000000..ef7cfbb89d60 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F32X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F32X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F64.html b/api/wasmtime_environ/data_structures/ir/types/constant.F64.html new file mode 100644 index 000000000000..db58101442e4 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F64X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.F64X2.html new file mode 100644 index 000000000000..e305bd0f72b9 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F64X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F64X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F64X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.F64X4.html new file mode 100644 index 000000000000..0bd8114ac98a --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F64X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F64X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.F64X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.F64X8.html new file mode 100644 index 000000000000..6189a3654fa1 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.F64X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.F64X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.FFLAGS.html b/api/wasmtime_environ/data_structures/ir/types/constant.FFLAGS.html new file mode 100644 index 000000000000..4caba8c55cf5 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.FFLAGS.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.FFLAGS.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I128.html b/api/wasmtime_environ/data_structures/ir/types/constant.I128.html new file mode 100644 index 000000000000..4d65b4685b29 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I128.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I128.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I128X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.I128X2.html new file mode 100644 index 000000000000..0e9e97193944 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I128X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I128X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I128X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.I128X4.html new file mode 100644 index 000000000000..58a272893b28 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I128X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I128X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I16.html b/api/wasmtime_environ/data_structures/ir/types/constant.I16.html new file mode 100644 index 000000000000..fd3260baa8a6 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I16X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.I16X16.html new file mode 100644 index 000000000000..8a228e895c40 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I16X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I16X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I16X32.html b/api/wasmtime_environ/data_structures/ir/types/constant.I16X32.html new file mode 100644 index 000000000000..f0cd7e3a51ce --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I16X32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I16X32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I16X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.I16X4.html new file mode 100644 index 000000000000..e2b1b68f6085 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I16X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I16X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I16X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.I16X8.html new file mode 100644 index 000000000000..7799ae5ef902 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I16X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I16X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I32.html b/api/wasmtime_environ/data_structures/ir/types/constant.I32.html new file mode 100644 index 000000000000..e98eae882550 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I32X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.I32X16.html new file mode 100644 index 000000000000..58cc786a9ac7 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I32X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I32X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I32X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.I32X2.html new file mode 100644 index 000000000000..4676027a1827 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I32X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I32X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I32X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.I32X4.html new file mode 100644 index 000000000000..b2551c4d4bd3 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I32X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I32X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I32X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.I32X8.html new file mode 100644 index 000000000000..3ff0e6bc5be7 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I32X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I32X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I64.html b/api/wasmtime_environ/data_structures/ir/types/constant.I64.html new file mode 100644 index 000000000000..9108b2cba4a7 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I64X2.html b/api/wasmtime_environ/data_structures/ir/types/constant.I64X2.html new file mode 100644 index 000000000000..46e5645c8cff --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I64X2.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I64X2.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I64X4.html b/api/wasmtime_environ/data_structures/ir/types/constant.I64X4.html new file mode 100644 index 000000000000..2dc1f6987992 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I64X4.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I64X4.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I64X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.I64X8.html new file mode 100644 index 000000000000..94b3ad7d7461 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I64X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I64X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I8.html b/api/wasmtime_environ/data_structures/ir/types/constant.I8.html new file mode 100644 index 000000000000..48398d3aa4d6 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I8X16.html b/api/wasmtime_environ/data_structures/ir/types/constant.I8X16.html new file mode 100644 index 000000000000..af1c5f846496 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I8X16.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I8X16.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I8X32.html b/api/wasmtime_environ/data_structures/ir/types/constant.I8X32.html new file mode 100644 index 000000000000..aee5193808f5 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I8X32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I8X32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I8X64.html b/api/wasmtime_environ/data_structures/ir/types/constant.I8X64.html new file mode 100644 index 000000000000..d37aafc556b7 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I8X64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I8X64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.I8X8.html b/api/wasmtime_environ/data_structures/ir/types/constant.I8X8.html new file mode 100644 index 000000000000..b679a48516b0 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.I8X8.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.I8X8.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.IFLAGS.html b/api/wasmtime_environ/data_structures/ir/types/constant.IFLAGS.html new file mode 100644 index 000000000000..b803cdba2200 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.IFLAGS.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.IFLAGS.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.INVALID.html b/api/wasmtime_environ/data_structures/ir/types/constant.INVALID.html new file mode 100644 index 000000000000..66f83f7869b1 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.INVALID.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.INVALID.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.R32.html b/api/wasmtime_environ/data_structures/ir/types/constant.R32.html new file mode 100644 index 000000000000..b3c4e415cc6b --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.R32.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.R32.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/constant.R64.html b/api/wasmtime_environ/data_structures/ir/types/constant.R64.html new file mode 100644 index 000000000000..205c85b1b4f4 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/constant.R64.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/constant.R64.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/index.html b/api/wasmtime_environ/data_structures/ir/types/index.html new file mode 100644 index 000000000000..7bd51dbf6b74 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/index.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/types/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/ir/types/struct.Type.html b/api/wasmtime_environ/data_structures/ir/types/struct.Type.html new file mode 100644 index 000000000000..729e32fdcfe1 --- /dev/null +++ b/api/wasmtime_environ/data_structures/ir/types/struct.Type.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../wasmtime_environ/ir/struct.Type.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/isa/enum.CallConv.html b/api/wasmtime_environ/data_structures/isa/enum.CallConv.html new file mode 100644 index 000000000000..546dc5443b79 --- /dev/null +++ b/api/wasmtime_environ/data_structures/isa/enum.CallConv.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/isa/enum.CallConv.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/isa/index.html b/api/wasmtime_environ/data_structures/isa/index.html new file mode 100644 index 000000000000..ab731470105f --- /dev/null +++ b/api/wasmtime_environ/data_structures/isa/index.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/isa/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/isa/struct.TargetFrontendConfig.html b/api/wasmtime_environ/data_structures/isa/struct.TargetFrontendConfig.html new file mode 100644 index 000000000000..68160d756f65 --- /dev/null +++ b/api/wasmtime_environ/data_structures/isa/struct.TargetFrontendConfig.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/isa/struct.TargetFrontendConfig.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/isa/trait.TargetIsa.html b/api/wasmtime_environ/data_structures/isa/trait.TargetIsa.html new file mode 100644 index 000000000000..0b2139641da7 --- /dev/null +++ b/api/wasmtime_environ/data_structures/isa/trait.TargetIsa.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/isa/trait.TargetIsa.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/isa/type.RegUnit.html b/api/wasmtime_environ/data_structures/isa/type.RegUnit.html new file mode 100644 index 000000000000..78f736930261 --- /dev/null +++ b/api/wasmtime_environ/data_structures/isa/type.RegUnit.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/isa/type.RegUnit.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/settings/fn.builder.html b/api/wasmtime_environ/data_structures/settings/fn.builder.html new file mode 100644 index 000000000000..c67b77dff233 --- /dev/null +++ b/api/wasmtime_environ/data_structures/settings/fn.builder.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/settings/fn.builder.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/settings/index.html b/api/wasmtime_environ/data_structures/settings/index.html new file mode 100644 index 000000000000..a5b02c50f1d6 --- /dev/null +++ b/api/wasmtime_environ/data_structures/settings/index.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/settings/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/settings/struct.Builder.html b/api/wasmtime_environ/data_structures/settings/struct.Builder.html new file mode 100644 index 000000000000..a0409db659de --- /dev/null +++ b/api/wasmtime_environ/data_structures/settings/struct.Builder.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/settings/struct.Builder.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/settings/struct.Flags.html b/api/wasmtime_environ/data_structures/settings/struct.Flags.html new file mode 100644 index 000000000000..d132b13ae1d8 --- /dev/null +++ b/api/wasmtime_environ/data_structures/settings/struct.Flags.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/settings/struct.Flags.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/settings/trait.Configurable.html b/api/wasmtime_environ/data_structures/settings/trait.Configurable.html new file mode 100644 index 000000000000..febfa18a4fe5 --- /dev/null +++ b/api/wasmtime_environ/data_structures/settings/trait.Configurable.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/settings/trait.Configurable.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/enum.GlobalInit.html b/api/wasmtime_environ/data_structures/wasm/enum.GlobalInit.html new file mode 100644 index 000000000000..5682d8373e44 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/enum.GlobalInit.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/enum.GlobalInit.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/enum.TableElementType.html b/api/wasmtime_environ/data_structures/wasm/enum.TableElementType.html new file mode 100644 index 000000000000..0e2fed292675 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/enum.TableElementType.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/enum.TableElementType.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/fn.get_vmctx_value_label.html b/api/wasmtime_environ/data_structures/wasm/fn.get_vmctx_value_label.html new file mode 100644 index 000000000000..3c5546978918 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/fn.get_vmctx_value_label.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/fn.get_vmctx_value_label.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/index.html b/api/wasmtime_environ/data_structures/wasm/index.html new file mode 100644 index 000000000000..1830440b7dd4 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/index.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/index.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.DefinedFuncIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.DefinedFuncIndex.html new file mode 100644 index 000000000000..6eea0520f039 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.DefinedFuncIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.DefinedFuncIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.DefinedGlobalIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.DefinedGlobalIndex.html new file mode 100644 index 000000000000..9c04182ce881 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.DefinedGlobalIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.DefinedGlobalIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.DefinedMemoryIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.DefinedMemoryIndex.html new file mode 100644 index 000000000000..065567078bf2 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.DefinedMemoryIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.DefinedMemoryIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.DefinedTableIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.DefinedTableIndex.html new file mode 100644 index 000000000000..3fb74d00a88b --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.DefinedTableIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.DefinedTableIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.FuncIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.FuncIndex.html new file mode 100644 index 000000000000..d3b2f330dfef --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.FuncIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.FuncIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.Global.html b/api/wasmtime_environ/data_structures/wasm/struct.Global.html new file mode 100644 index 000000000000..275bec1456e8 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.Global.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.Global.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.GlobalIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.GlobalIndex.html new file mode 100644 index 000000000000..54b4f0151703 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.GlobalIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.GlobalIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.Memory.html b/api/wasmtime_environ/data_structures/wasm/struct.Memory.html new file mode 100644 index 000000000000..e238c15c5a6c --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.Memory.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.Memory.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.MemoryIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.MemoryIndex.html new file mode 100644 index 000000000000..659d9c2cfc12 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.MemoryIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.MemoryIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.SignatureIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.SignatureIndex.html new file mode 100644 index 000000000000..9b1859e8da54 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.SignatureIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.SignatureIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.Table.html b/api/wasmtime_environ/data_structures/wasm/struct.Table.html new file mode 100644 index 000000000000..c3b76f966fd6 --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.Table.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.Table.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/data_structures/wasm/struct.TableIndex.html b/api/wasmtime_environ/data_structures/wasm/struct.TableIndex.html new file mode 100644 index 000000000000..f9a68986082b --- /dev/null +++ b/api/wasmtime_environ/data_structures/wasm/struct.TableIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../wasmtime_environ/wasm/struct.TableIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/entity/index.html b/api/wasmtime_environ/entity/index.html new file mode 100644 index 000000000000..8d63bdb17307 --- /dev/null +++ b/api/wasmtime_environ/entity/index.html @@ -0,0 +1,7 @@ +| BoxedSlice | A slice mapping |
| PrimaryMap | A primary mapping |
| EntityRef | A type wrapping a small integer index should implement |
A slice mapping K -> V allocating dense entity references.
The BoxedSlice data structure uses the dense index space to implement a map with a boxed
+slice.
impl<K, V> BoxedSlice<K, V> where
K: EntityRef, pub unsafe fn from_raw(raw: *mut [V]) -> BoxedSlice<K, V>Create a new slice from a raw pointer. A safer way to create slices is
+to use PrimaryMap::into_boxed_slice().
This relies on raw pointing to a valid slice of Vs.
pub fn is_valid(&self, k: K) -> boolCheck if k is a valid key in the map.
pub fn get(&self, k: K) -> Option<&V>Get the element at k if it exists.
pub fn get_mut(&mut self, k: K) -> Option<&mut V>Get the element at k if it exists, mutable version.
pub fn is_empty(&self) -> boolIs this map completely empty?
+pub fn len(&self) -> usizeGet the total number of entity references created.
+pub fn keys(&self) -> Keys<K>Iterate over all the keys in this map.
+pub fn values(&self) -> Iter<V>Iterate over all the values in this map.
+pub fn values_mut(&mut self) -> IterMut<V>Iterate over all the values in this map, mutable edition.
+pub fn iter(&self) -> Iter<K, V>Iterate over all the keys and values in this map.
+pub fn iter_mut(&mut self) -> IterMut<K, V>Iterate over all the keys and values in this map, mutable edition.
+pub fn last(&self) -> Option<&V>Returns the last element that was inserted in the map.
+impl<K, V> Clone for BoxedSlice<K, V> where
K: Clone + EntityRef,
V: Clone, fn clone(&self) -> BoxedSlice<K, V>fn clone_from(&mut self, source: &Self)1.0.0[src]impl<K, V> Debug for BoxedSlice<K, V> where
K: Debug + EntityRef,
V: Debug, impl<K, V> Index<K> for BoxedSlice<K, V> where
K: EntityRef, Immutable indexing into a BoxedSlice.
+The indexed value must be in the map.
impl<K, V> IndexMut<K> for BoxedSlice<K, V> where
K: EntityRef, Mutable indexing into a BoxedSlice.
impl<'a, K, V> IntoIterator for &'a mut BoxedSlice<K, V> where
K: EntityRef, type Item = (K, &'a mut V)The type of the elements being iterated over.
+type IntoIter = IterMut<'a, K, V>Which kind of iterator are we turning this into?
+fn into_iter(self) -> <&'a mut BoxedSlice<K, V> as IntoIterator>::IntoIterimpl<'a, K, V> IntoIterator for &'a BoxedSlice<K, V> where
K: EntityRef, type Item = (K, &'a V)The type of the elements being iterated over.
+type IntoIter = Iter<'a, K, V>Which kind of iterator are we turning this into?
+fn into_iter(self) -> <&'a BoxedSlice<K, V> as IntoIterator>::IntoIterimpl<K, V> RefUnwindSafe for BoxedSlice<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe, impl<K, V> Send for BoxedSlice<K, V> where
K: Send,
V: Send, impl<K, V> Sync for BoxedSlice<K, V> where
K: Sync,
V: Sync, impl<K, V> Unpin for BoxedSlice<K, V> where
K: Unpin, impl<K, V> UnwindSafe for BoxedSlice<K, V> where
K: UnwindSafe,
V: UnwindSafe, impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A primary mapping K -> V allocating dense entity references.
The PrimaryMap data structure uses the dense index space to implement a map with a vector.
A primary map contains the main definition of an entity, and it can be used to allocate new
+entity references with the push method.
There should only be a single PrimaryMap instance for a given EntityRef type, otherwise
+conflicting references will be created. Using unknown keys for indexing will cause a panic.
Note that PrimaryMap doesn't implement Deref or DerefMut, which would allow
+&PrimaryMap<K, V> to convert to &[V]. One of the main advantages of PrimaryMap is
+that it only allows indexing with the distinct EntityRef key type, so converting to a
+plain slice would make it easier to use incorrectly. To make a slice of a PrimaryMap, use
+into_boxed_slice.
impl<K, V> PrimaryMap<K, V> where
K: EntityRef, pub fn new() -> PrimaryMap<K, V>Create a new empty map.
+pub fn with_capacity(capacity: usize) -> PrimaryMap<K, V>Create a new empty map with the given capacity.
+pub fn is_valid(&self, k: K) -> boolCheck if k is a valid key in the map.
pub fn get(&self, k: K) -> Option<&V>Get the element at k if it exists.
pub fn get_mut(&mut self, k: K) -> Option<&mut V>Get the element at k if it exists, mutable version.
pub fn is_empty(&self) -> boolIs this map completely empty?
+pub fn len(&self) -> usizeGet the total number of entity references created.
+pub fn keys(&self) -> Keys<K>Iterate over all the keys in this map.
+pub fn values(&self) -> Iter<V>Iterate over all the values in this map.
+pub fn values_mut(&mut self) -> IterMut<V>Iterate over all the values in this map, mutable edition.
+pub fn iter(&self) -> Iter<K, V>Iterate over all the keys and values in this map.
+pub fn iter_mut(&mut self) -> IterMut<K, V>Iterate over all the keys and values in this map, mutable edition.
+pub fn clear(&mut self)Remove all entries from this map.
+pub fn next_key(&self) -> KGet the key that will be assigned to the next pushed value.
+pub fn push(&mut self, v: V) -> KAppend v to the mapping, assigning a new key which is returned.
pub fn last(&self) -> Option<&V>Returns the last element that was inserted in the map.
+pub fn reserve(&mut self, additional: usize)Reserves capacity for at least additional more elements to be inserted.
pub fn reserve_exact(&mut self, additional: usize)Reserves the minimum capacity for exactly additional more elements to be inserted.
pub fn shrink_to_fit(&mut self)Shrinks the capacity of the PrimaryMap as much as possible.
pub fn into_boxed_slice(self) -> BoxedSlice<K, V>Consumes this PrimaryMap and produces a BoxedSlice.
impl<K, V> Clone for PrimaryMap<K, V> where
K: Clone + EntityRef,
V: Clone, fn clone(&self) -> PrimaryMap<K, V>fn clone_from(&mut self, source: &Self)1.0.0[src]impl<K, V> Debug for PrimaryMap<K, V> where
K: Debug + EntityRef,
V: Debug, impl<'de, K, V> Deserialize<'de> for PrimaryMap<K, V> where
K: EntityRef,
V: Deserialize<'de>, fn deserialize<__D>(
__deserializer: __D
) -> Result<PrimaryMap<K, V>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl<K, V> Eq for PrimaryMap<K, V> where
K: Eq + EntityRef,
V: Eq, impl<K, V> FromIterator<V> for PrimaryMap<K, V> where
K: EntityRef, fn from_iter<T>(iter: T) -> PrimaryMap<K, V> where
T: IntoIterator<Item = V>, impl<K, V> Hash for PrimaryMap<K, V> where
K: Hash + EntityRef,
V: Hash, fn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl<K, V> Index<K> for PrimaryMap<K, V> where
K: EntityRef, Immutable indexing into an PrimaryMap.
+The indexed value must be in the map.
impl<K, V> IndexMut<K> for PrimaryMap<K, V> where
K: EntityRef, Mutable indexing into an PrimaryMap.
impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V> where
K: EntityRef, type Item = (K, &'a V)The type of the elements being iterated over.
+type IntoIter = Iter<'a, K, V>Which kind of iterator are we turning this into?
+fn into_iter(self) -> <&'a PrimaryMap<K, V> as IntoIterator>::IntoIterimpl<'a, K, V> IntoIterator for &'a mut PrimaryMap<K, V> where
K: EntityRef, type Item = (K, &'a mut V)The type of the elements being iterated over.
+type IntoIter = IterMut<'a, K, V>Which kind of iterator are we turning this into?
+fn into_iter(self) -> <&'a mut PrimaryMap<K, V> as IntoIterator>::IntoIterimpl<K, V> PartialEq<PrimaryMap<K, V>> for PrimaryMap<K, V> where
K: PartialEq<K> + EntityRef,
V: PartialEq<V>, fn eq(&self, other: &PrimaryMap<K, V>) -> boolfn ne(&self, other: &PrimaryMap<K, V>) -> boolimpl<K, V> Serialize for PrimaryMap<K, V> where
K: EntityRef,
V: Serialize, fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl<K, V> StructuralEq for PrimaryMap<K, V> where
K: EntityRef, impl<K, V> StructuralPartialEq for PrimaryMap<K, V> where
K: EntityRef, impl<K, V> RefUnwindSafe for PrimaryMap<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe, impl<K, V> Send for PrimaryMap<K, V> where
K: Send,
V: Send, impl<K, V> Sync for PrimaryMap<K, V> where
K: Sync,
V: Sync, impl<K, V> Unpin for PrimaryMap<K, V> where
K: Unpin,
V: Unpin, impl<K, V> UnwindSafe for PrimaryMap<K, V> where
K: UnwindSafe,
V: UnwindSafe, impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A type wrapping a small integer index should implement EntityRef so it can be used as the key
+of an SecondaryMap or SparseMap.
fn new(usize) -> SelfCreate a new entity reference from a small integer. +This should crash if the requested index is not representable.
+fn index(self) -> usizeGet the index that was used to create this entity reference.
+impl EntityRef for JumpTableimpl EntityRef for SigRefimpl EntityRef for Tableimpl EntityRef for Instimpl EntityRef for GlobalValueimpl EntityRef for Constantimpl EntityRef for Blockimpl EntityRef for RegClassIndeximpl EntityRef for FuncRefimpl EntityRef for Heapimpl EntityRef for StackSlotimpl EntityRef for Immediateimpl EntityRef for Valueimpl EntityRef for Loopimpl EntityRef for Variableimpl EntityRef for ValueLabelfn new(index: usize) -> ValueLabelfn index(self) -> usizeimpl EntityRef for DefinedFuncIndexfn new(index: usize) -> DefinedFuncIndexfn index(self) -> usizeimpl EntityRef for DefinedGlobalIndexfn new(index: usize) -> DefinedGlobalIndexfn index(self) -> usizeimpl EntityRef for DefinedMemoryIndexfn new(index: usize) -> DefinedMemoryIndexfn index(self) -> usizeimpl EntityRef for DefinedTableIndexfn new(index: usize) -> DefinedTableIndexfn index(self) -> usizeimpl EntityRef for FuncIndeximpl EntityRef for GlobalIndexfn new(index: usize) -> GlobalIndexfn index(self) -> usizeimpl EntityRef for MemoryIndexfn new(index: usize) -> MemoryIndexfn index(self) -> usizeimpl EntityRef for SignatureIndexfn new(index: usize) -> SignatureIndexfn index(self) -> usizeimpl EntityRef for TableIndexfn new(index: usize) -> TableIndexfn index(self) -> usizeAn error while compiling WebAssembly to machine code.
+A wasm translation error occured.
+Codegen(String)A compilation error occured.
+A compilation error occured.
+impl Debug for CompileError[src]impl Display for CompileError[src]impl Error for CompileError[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<WasmError> for CompileError[src]impl RefUnwindSafe for CompileErrorimpl Send for CompileErrorimpl Sync for CompileErrorimpl Unpin for CompileErrorimpl UnwindSafe for CompileErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Compiled function unwind information.
+No info.
+Windows UNWIND_INFO.
+Frame layout info.
+impl CompiledFunctionUnwindInfo[src]pub fn new(isa: &dyn TargetIsa, context: &Context) -> Self[src]Constructs unwind info object.
+pub fn is_empty(&self) -> bool[src]Retuns true is no unwind info data.
+pub fn len(&self) -> usize[src]Returns size of serilized unwind info.
+pub fn serialize(
&self,
dest: &mut [u8],
relocs: &mut Vec<CompiledFunctionUnwindInfoReloc>
)[src]Serializes data into byte array.
+impl Clone for CompiledFunctionUnwindInfo[src]fn clone(&self) -> CompiledFunctionUnwindInfo[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for CompiledFunctionUnwindInfo[src]impl<'de> Deserialize<'de> for CompiledFunctionUnwindInfo[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for CompiledFunctionUnwindInfo[src]impl PartialEq<CompiledFunctionUnwindInfo> for CompiledFunctionUnwindInfo[src]fn eq(&self, other: &CompiledFunctionUnwindInfo) -> bool[src]fn ne(&self, other: &CompiledFunctionUnwindInfo) -> bool[src]impl Serialize for CompiledFunctionUnwindInfo[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for CompiledFunctionUnwindInfo[src]impl StructuralPartialEq for CompiledFunctionUnwindInfo[src]impl RefUnwindSafe for CompiledFunctionUnwindInfoimpl Send for CompiledFunctionUnwindInfoimpl Sync for CompiledFunctionUnwindInfoimpl Unpin for CompiledFunctionUnwindInfoimpl UnwindSafe for CompiledFunctionUnwindInfoimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An entity to export.
+Function(FuncIndex)Function export.
+Table(TableIndex)Table export.
+Memory(MemoryIndex)Memory export.
+Global(GlobalIndex)Global export.
+impl Clone for Export[src]impl Debug for Export[src]impl Eq for Export[src]impl Hash for Export[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for Export[src]fn cmp(&self, other: &Export) -> Ordering[src]#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<Export> for Export[src]impl PartialOrd<Export> for Export[src]fn partial_cmp(&self, other: &Export) -> Option<Ordering>[src]fn lt(&self, other: &Export) -> bool[src]fn le(&self, other: &Export) -> bool[src]fn gt(&self, other: &Export) -> bool[src]fn ge(&self, other: &Export) -> bool[src]impl StructuralEq for Export[src]impl StructuralPartialEq for Export[src]impl RefUnwindSafe for Exportimpl Send for Exportimpl Sync for Exportimpl Unpin for Exportimpl UnwindSafe for Exportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Implemenation styles for WebAssembly linear memory.
+The actual memory can be resized and moved.
+Addresss space is allocated up front.
+bound: u32The number of mapped and unmapped pages.
+impl MemoryStyle[src]pub fn for_memory(memory: Memory, tunables: &Tunables) -> (Self, u64)[src]Decide on an implementation style for the given Memory.
impl Clone for MemoryStyle[src]fn clone(&self) -> MemoryStyle[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for MemoryStyle[src]impl Hash for MemoryStyle[src]impl RefUnwindSafe for MemoryStyleimpl Send for MemoryStyleimpl Sync for MemoryStyleimpl Unpin for MemoryStyleimpl UnwindSafe for MemoryStyleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Memory definition offset in the VMContext structure.
+Not available.
+Defined(u32)Offset to the defined memory.
+Imported(u32)Offset to the imported memory.
+impl Clone for ModuleMemoryOffset[src]fn clone(&self) -> ModuleMemoryOffset[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ModuleMemoryOffset[src]impl RefUnwindSafe for ModuleMemoryOffsetimpl Send for ModuleMemoryOffsetimpl Sync for ModuleMemoryOffsetimpl Unpin for ModuleMemoryOffsetimpl UnwindSafe for ModuleMemoryOffsetimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Destination function. Can be either user function or some special one, like memory.grow.
UserFunc(FuncIndex)The user function index.
+A compiler-generated libcall.
+JumpTable(FuncIndex, JumpTable)Jump table index.
+impl Clone for RelocationTarget[src]fn clone(&self) -> RelocationTarget[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for RelocationTarget[src]impl Debug for RelocationTarget[src]impl<'de> Deserialize<'de> for RelocationTarget[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for RelocationTarget[src]impl PartialEq<RelocationTarget> for RelocationTarget[src]fn eq(&self, other: &RelocationTarget) -> bool[src]fn ne(&self, other: &RelocationTarget) -> bool[src]impl Serialize for RelocationTarget[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for RelocationTarget[src]impl StructuralPartialEq for RelocationTarget[src]impl RefUnwindSafe for RelocationTargetimpl Send for RelocationTargetimpl Sync for RelocationTargetimpl Unpin for RelocationTargetimpl UnwindSafe for RelocationTargetimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Implemenation styles for WebAssembly tables.
+Signatures are stored in the table and checked in the caller.
+impl TableStyle[src]pub fn for_table(_table: Table, _tunables: &Tunables) -> Self[src]Decide on an implementation style for the given Table.
impl Clone for TableStyle[src]fn clone(&self) -> TableStyle[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for TableStyle[src]impl Hash for TableStyle[src]impl RefUnwindSafe for TableStyleimpl Send for TableStyleimpl Sync for TableStyleimpl Unpin for TableStyleimpl UnwindSafe for TableStyleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn cache_create_new_config<P: AsRef<Path> + Debug>(
config_file: Option<P>
) -> Result<PathBuf>
Creates a new configuration file at specified path, or default path if None is passed. +Fails if file already exists.
+pub fn translate_signature(sig: Signature, pointer_type: Type) -> Signature
Add environment-specific function parameters.
+Redirecting to ../../wasmtime_environ/struct.BuiltinFunctionIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/index.html b/api/wasmtime_environ/index.html new file mode 100644 index 000000000000..5c9df9e977ae --- /dev/null +++ b/api/wasmtime_environ/index.html @@ -0,0 +1,61 @@ +Standalone environment for WebAssembly using Cranelift. Provides functions to translate
+get_global, set_global, memory.size, memory.grow, call_indirect that hardcode in
+the translation the base addresses of regions of memory that will hold the globals, tables and
+linear memories.
pub use crate::cranelift::Cranelift; |
| cranelift | Support for compiling with Cranelift. + |
| entity | |
| ir | |
| isa | |
| settings | |
| wasm |
| BuiltinFunctionIndex | An index type for builtin functions. + |
| CacheConfig | Global configuration for how the cache is managed + |
| Compilation | The result of compiling a WebAssembly module's functions. + |
| CompiledFunction | Compiled function: machine code body, jump table offsets, and unwind information. + |
| CompiledFunctionUnwindInfoReloc | Relocation entry for unwind info. + |
| DataInitializer | A data initializer for linear memory. + |
| DataInitializerLocation | A memory index and offset within that memory where a data initialization +should is to be performed. + |
| FunctionAddressMap | Function and its instructions addresses mappings. + |
| FunctionBodyData | Contains function data: byte code and its offset in the module. + |
| InstructionAddressMap | Single source location to generated address mapping. + |
| MemoryPlan | A WebAssembly linear memory description along with our chosen style for +implementing it. + |
| Module | A translated WebAssembly module, excluding the function bodies and +memory initializers. + |
| ModuleEnvironment | Object containing the standalone environment information. + |
| ModuleTranslation | The result of translating via |
| ModuleVmctxInfo | Module |
| Relocation | A record of a relocation to perform. + |
| TableElements | A WebAssembly table initializer. + |
| TablePlan | A WebAssembly table description along with our chosen style for +implementing it. + |
| TargetSharedSignatureIndex | Target specific type for shared signature index. + |
| TrapInformation | Information about trap. + |
| Tunables | Tunable parameters for WebAssembly compilation. + |
| VMOffsets | This class computes offsets to fields within |
| CompileError | An error while compiling WebAssembly to machine code. + |
| CompiledFunctionUnwindInfo | Compiled function unwind information. + |
| Export | An entity to export. + |
| MemoryStyle | Implemenation styles for WebAssembly linear memory. + |
| ModuleMemoryOffset | Memory definition offset in the VMContext structure. + |
| RelocationTarget | Destination function. Can be either user function or some special one, like |
| TableStyle | Implemenation styles for WebAssembly tables. + |
| VERSION | Version number of this crate. + |
| WASM_MAX_PAGES | The number of pages we can have before we run out of byte index space. + |
| WASM_PAGE_SIZE | WebAssembly page sizes are defined to be 64KiB. + |
| Compiler | An implementation of a compiler from parsed WebAssembly module to native code. + |
| cache_create_new_config | Creates a new configuration file at specified path, or default path if None is passed. +Fails if file already exists. + |
| translate_signature | Add environment-specific function parameters. + |
| ModuleAddressMap | Module functions addresses mappings. + |
| Relocations | Relocations to apply to function bodies. + |
| Traps | Information about traps associated with the functions where the traps are placed. + |
| ValueLabelsRanges | Value ranges for functions. + |
The special purpose of a function argument.
+Function arguments and return values are used to pass user program values between functions, +but they are also used to represent special registers with significance to the ABI such as +frame pointers and callee-saved registers.
+The argument purpose is used to indicate any special meaning of an argument or return value.
+A normal user program value passed to or from a function.
+Struct return pointer.
+When a function needs to return more data than will fit in registers, the caller passes a +pointer to a memory location where the return value can be written. In some ABIs, this +struct return pointer is passed in a specific register.
+This argument kind can also appear as a return value for ABIs that require a function with
+a StructReturn pointer argument to also return that pointer in a register.
The link register.
+Most RISC architectures implement calls by saving the return address in a designated
+register rather than pushing it on the stack. This is represented with a Link argument.
Similarly, some return instructions expect the return address in a register represented as
+a Link return value.
The frame pointer.
+This indicates the frame pointer register which has a special meaning in some ABIs.
+The frame pointer appears as an argument and as a return value since it is a callee-saved +register.
+A callee-saved register.
+Some calling conventions have registers that must be saved by the callee. These registers
+are represented as CalleeSaved arguments and return values.
A VM context pointer.
+This is a pointer to a context struct containing details about the current sandbox. It is
+used as a base pointer for vmctx global values.
A signature identifier.
+This is a special-purpose argument used to identify the calling convention expected by the +caller in an indirect call. The callee can verify that the expected signature ID matches.
+A stack limit pointer.
+This is a pointer to a stack limit. It is used to check the current stack pointer +against. Can only appear once in a signature.
+impl Clone for ArgumentPurposefn clone(&self) -> ArgumentPurposefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for ArgumentPurposeimpl Debug for ArgumentPurposeimpl Display for ArgumentPurposeimpl Eq for ArgumentPurposeimpl FromStr for ArgumentPurposetype Err = ()The associated error which can be returned from parsing.
+fn from_str(s: &str) -> Result<ArgumentPurpose, ()>impl Hash for ArgumentPurposefn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<ArgumentPurpose> for ArgumentPurposefn eq(&self, other: &ArgumentPurpose) -> bool#[must_use]
+fn ne(&self, other: &Rhs) -> bool1.0.0[src]impl StructuralEq for ArgumentPurposeimpl StructuralPartialEq for ArgumentPurposeimpl RefUnwindSafe for ArgumentPurposeimpl Send for ArgumentPurposeimpl Sync for ArgumentPurposeimpl Unpin for ArgumentPurposeimpl UnwindSafe for ArgumentPurposeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A trap code describing the reason for a trap.
+All trap instructions have an explicit trap code.
+The current stack space was exhausted.
+On some platforms, a stack overflow may also be indicated by a segmentation fault from the +stack guard page.
+A heap_addr instruction detected an out-of-bounds error.
Note that not all out-of-bounds heap accesses are reported this way; +some are detected by a segmentation fault on the heap unmapped or +offset-guard pages.
+A table_addr instruction detected an out-of-bounds error.
Other bounds checking error.
+Indirect call to a null table entry.
+Signature mismatch on indirect call.
+An integer arithmetic operation caused an overflow.
+An integer division by zero.
+Failed float-to-int conversion.
+Code that was supposed to have been unreachable was reached.
+Execution has potentially run too long and may be interrupted. +This trap is resumable.
+User(u16)A user-defined trap code.
+impl Clone for TrapCodefn clone(&self) -> TrapCodefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TrapCodeimpl Debug for TrapCodeimpl<'de> Deserialize<'de> for TrapCodefn deserialize<__D>(
__deserializer: __D
) -> Result<TrapCode, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Display for TrapCodeimpl Eq for TrapCodeimpl FromStr for TrapCodetype Err = ()The associated error which can be returned from parsing.
+fn from_str(s: &str) -> Result<TrapCode, <TrapCode as FromStr>::Err>impl Hash for TrapCodefn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<TrapCode> for TrapCodeimpl Serialize for TrapCodefn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for TrapCodeimpl StructuralPartialEq for TrapCodeimpl RefUnwindSafe for TrapCodeimpl Send for TrapCodeimpl Sync for TrapCodeimpl Unpin for TrapCodeimpl UnwindSafe for TrapCodeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Value location.
+This value has not been assigned to a location yet.
+Reg(u16)Value is assigned to a register.
+Value is assigned to a stack slot.
+impl ValueLocpub fn is_assigned(self) -> boolIs this an assigned location? (That is, not Unassigned).
pub fn unwrap_reg(self) -> u16Get the register unit of this location, or panic.
+pub fn unwrap_stack(self) -> StackSlotGet the stack slot of this location, or panic.
+pub fn display<'a, R>(self, regs: R) -> DisplayValueLoc<'a> where
R: Into<Option<&'a RegInfo>>, Return an object that can display this value location, using the register info from the +target ISA.
+impl Clone for ValueLocfn clone(&self) -> ValueLocfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for ValueLocimpl Debug for ValueLocimpl Default for ValueLocimpl<'de> Deserialize<'de> for ValueLocfn deserialize<__D>(
__deserializer: __D
) -> Result<ValueLoc, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Eq for ValueLocimpl PartialEq<ValueLoc> for ValueLocimpl Serialize for ValueLocfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for ValueLocimpl StructuralPartialEq for ValueLocimpl RefUnwindSafe for ValueLocimpl Send for ValueLocimpl Sync for ValueLocimpl Unpin for ValueLocimpl UnwindSafe for ValueLocimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]| types | Common types for the Cranelift code generator. + |
| AbiParam | Function parameter or return value descriptor. + |
| Signature | Function signature. + |
| SourceLoc | A source location. + |
| StackSlots | Stack frame manager. + |
| Type | The type of an SSA value. + |
| ValueLabel | Marked with a label value. + |
| ArgumentPurpose | The special purpose of a function argument. + |
| TrapCode | A trap code describing the reason for a trap. + |
| ValueLoc | Value location. + |
| ValueLabelsRanges | Resulting map of Value labels and their ranges/locations. + |
Function parameter or return value descriptor.
+This describes the value type being passed to or from a function along with flags that affect +how the argument is passed.
+value_type: TypeType of the argument value.
+purpose: ArgumentPurposeSpecial purpose of argument, or Normal.
extension: ArgumentExtensionMethod for extending argument to a full register.
+location: ArgumentLocABI-specific location of this argument, or Unassigned for arguments that have not yet
+been legalized.
impl AbiParampub fn new(vt: Type) -> AbiParamCreate a parameter with default flags.
+pub fn special(vt: Type, purpose: ArgumentPurpose) -> AbiParamCreate a special-purpose parameter that is not (yet) bound to a specific register.
+pub fn special_reg(vt: Type, purpose: ArgumentPurpose, regunit: u16) -> AbiParamCreate a parameter for a special-purpose register.
+pub fn uext(self) -> AbiParamConvert self to a parameter with the uext flag set.
pub fn sext(self) -> AbiParamConvert self to a parameter type with the sext flag set.
pub fn display<'a, R>(&'a self, regs: R) -> DisplayAbiParam<'a> where
R: Into<Option<&'a RegInfo>>, Return an object that can display self with correct register names.
impl Clone for AbiParamfn clone(&self) -> AbiParamfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for AbiParamimpl Debug for AbiParamimpl Display for AbiParamimpl Eq for AbiParamimpl Hash for AbiParamfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<AbiParam> for AbiParamimpl StructuralEq for AbiParamimpl StructuralPartialEq for AbiParamimpl RefUnwindSafe for AbiParamimpl Send for AbiParamimpl Sync for AbiParamimpl Unpin for AbiParamimpl UnwindSafe for AbiParamimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Function signature.
+The function signature describes the types of formal parameters and return values along with +other details that are needed to call a function correctly.
+A signature can optionally include ISA-specific ABI information which specifies exactly how +arguments and return values are passed.
+params: Vec<AbiParam>The arguments passed to the function.
+returns: Vec<AbiParam>Values returned from the function.
+call_conv: CallConvCalling convention.
+impl Signaturepub fn new(call_conv: CallConv) -> SignatureCreate a new blank signature.
+pub fn clear(&mut self, call_conv: CallConv)Clear the signature so it is identical to a fresh one returned by new().
pub fn display<'a, R>(&'a self, regs: R) -> DisplaySignature<'a> where
R: Into<Option<&'a RegInfo>>, Return an object that can display self with correct register names.
pub fn special_param_index(&self, purpose: ArgumentPurpose) -> Option<usize>Find the index of a presumed unique special-purpose parameter.
+pub fn special_return_index(&self, purpose: ArgumentPurpose) -> Option<usize>Find the index of a presumed unique special-purpose parameter.
+pub fn uses_special_param(&self, purpose: ArgumentPurpose) -> boolDoes this signature have a parameter whose ArgumentPurpose is
+purpose?
pub fn uses_special_return(&self, purpose: ArgumentPurpose) -> boolDoes this signature have a return whose ArgumentPurpose is purpose?
pub fn num_special_params(&self) -> usizeHow many special parameters does this function have?
+pub fn num_special_returns(&self) -> usizeHow many special returns does this function have?
+pub fn uses_struct_return_param(&self) -> boolDoes this signature take an struct return pointer parameter?
+pub fn is_multi_return(&self) -> boolDoes this return more than one normal value? (Pre-struct return +legalization)
+impl Clone for Signaturefn clone(&self) -> Signaturefn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for Signatureimpl Display for Signatureimpl Eq for Signatureimpl Hash for Signaturefn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Signature> for Signatureimpl StructuralEq for Signatureimpl StructuralPartialEq for Signatureimpl RefUnwindSafe for Signatureimpl Send for Signatureimpl Sync for Signatureimpl Unpin for Signatureimpl UnwindSafe for Signatureimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A source location.
+This is an opaque 32-bit number attached to each Cranelift IR instruction. Cranelift does not +interpret source locations in any way, they are simply preserved from the input to the output.
+The default source location uses the all-ones bit pattern !0. It is used for instructions
+that can't be given a real source location.
impl SourceLocpub fn new(bits: u32) -> SourceLocCreate a new source location with the given bits.
+pub fn is_default(self) -> boolIs this the default source location?
+pub fn bits(self) -> u32Read the bits of this source location.
+impl Clone for SourceLocfn clone(&self) -> SourceLocfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for SourceLocimpl Debug for SourceLocimpl Default for SourceLocimpl<'de> Deserialize<'de> for SourceLocfn deserialize<__D>(
__deserializer: __D
) -> Result<SourceLoc, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Display for SourceLocimpl Eq for SourceLocimpl PartialEq<SourceLoc> for SourceLocimpl Serialize for SourceLocfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for SourceLocimpl StructuralPartialEq for SourceLocimpl RefUnwindSafe for SourceLocimpl Send for SourceLocimpl Sync for SourceLocimpl Unpin for SourceLocimpl UnwindSafe for SourceLocimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Stack frame manager.
+Keep track of all the stack slots used by a function.
+layout_info: Option<StackLayoutInfo>Layout information computed from layout_stack.
impl StackSlotsStack slot manager functions that behave mostly like an entity map.
+pub fn new() -> StackSlotsCreate an empty stack slot manager.
+pub fn clear(&mut self)Clear out everything.
+pub fn push(&mut self, data: StackSlotData) -> StackSlotAllocate a new stack slot.
+This function should be primarily used by the text format parser. There are more convenient +functions for creating specific kinds of stack slots below.
+pub fn is_valid(&self, ss: StackSlot) -> boolCheck if ss is a valid stack slot reference.
pub fn iter(&self) -> Iter<StackSlot, StackSlotData>Get an iterator over all the stack slot keys.
+pub fn iter_mut(&mut self) -> IterMut<StackSlot, StackSlotData>Get an iterator over all the stack slot keys, mutable edition.
+pub fn values(&self) -> Iter<StackSlotData>Get an iterator over all the stack slot records.
+pub fn values_mut(&mut self) -> IterMut<StackSlotData>Get an iterator over all the stack slot records, mutable edition.
+pub fn keys(&self) -> Keys<StackSlot>Get an iterator over all the stack slot keys.
+pub fn next_key(&self) -> StackSlotGet a reference to the next stack slot that would be created by push().
This should just be used by the parser.
+impl StackSlotsHigher-level stack frame manipulation functions.
+pub fn make_spill_slot(&mut self, ty: Type) -> StackSlotCreate a new spill slot for spilling values of type ty.
pub fn make_incoming_arg(&mut self, ty: Type, offset: i32) -> StackSlotCreate a stack slot representing an incoming function argument.
+pub fn get_outgoing_arg(&mut self, ty: Type, offset: i32) -> StackSlotGet a stack slot representing an outgoing argument.
+This may create a new stack slot, or reuse an existing outgoing stack slot with the +requested offset and size.
+The requested offset is relative to this function's stack pointer immediately before making +the call.
+pub fn get_emergency_slot(
&mut self,
ty: Type,
in_use: &[PackedOption<StackSlot>]
) -> StackSlotGet an emergency spill slot that can be used to store a ty value.
This may allocate a new slot, or it may reuse an existing emergency spill slot, excluding
+any slots in the in_use list.
impl Clone for StackSlotsfn clone(&self) -> StackSlotsfn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for StackSlotsimpl<'de> Deserialize<'de> for StackSlotsfn deserialize<__D>(
__deserializer: __D
) -> Result<StackSlots, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Eq for StackSlotsimpl Index<StackSlot> for StackSlotstype Output = StackSlotDataThe returned type after indexing.
+fn index(&self, ss: StackSlot) -> &StackSlotDataimpl IndexMut<StackSlot> for StackSlotsfn index_mut(&mut self, ss: StackSlot) -> &mut StackSlotDataimpl PartialEq<StackSlots> for StackSlotsfn eq(&self, other: &StackSlots) -> boolfn ne(&self, other: &StackSlots) -> boolimpl Serialize for StackSlotsfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for StackSlotsimpl StructuralPartialEq for StackSlotsimpl RefUnwindSafe for StackSlotsimpl Send for StackSlotsimpl Sync for StackSlotsimpl Unpin for StackSlotsimpl UnwindSafe for StackSlotsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The type of an SSA value.
+The INVALID type isn't a real type, and is used as a placeholder in the IR where a type
+field is present put no type is needed, such as the controlling type variable for a
+non-polymorphic instruction.
Basic integer types: I8, I16, I32, I64, and I128. These types are sign-agnostic.
Basic floating point types: F32 and F64. IEEE single and double precision.
Boolean types: B1, B8, B16, B32, B64, and B128. These all encode 'true' or 'false'. The
+larger types use redundant bits.
SIMD vector types have power-of-two lanes, up to 256. Lanes can be any int/float/bool type.
+impl Typepub fn lane_type(self) -> TypeGet the lane type of this SIMD vector type.
+A lane type is the same as a SIMD vector type with one lane, so it returns itself.
+pub fn lane_of(self) -> TypeThe type transformation that returns the lane type of a type variable; it is just a +renaming of lane_type() to be used in context where we think in terms of type variable +transformations.
+pub fn log2_lane_bits(self) -> u8Get log_2 of the number of bits in a lane.
+pub fn lane_bits(self) -> u8Get the number of bits in a lane.
+pub fn int(bits: u16) -> Option<Type>Get an integer type with the requested number of bits.
+pub fn as_bool_pedantic(self) -> TypeGet a type with the same number of lanes as this type, but with the lanes replaced by +booleans of the same size.
+Lane types are treated as vectors with one lane, so they are converted to the multi-bit +boolean types.
+pub fn as_bool(self) -> TypeGet a type with the same number of lanes as this type, but with the lanes replaced by +booleans of the same size.
+Scalar types are all converted to b1 which is usually what you want.
pub fn half_width(self) -> Option<Type>Get a type with the same number of lanes as this type, but with lanes that are half the +number of bits.
+pub fn double_width(self) -> Option<Type>Get a type with the same number of lanes as this type, but with lanes that are twice the +number of bits.
+pub fn is_invalid(self) -> boolIs this the INVALID type?
+pub fn is_special(self) -> boolIs this a special type?
+pub fn is_lane(self) -> boolIs this a lane type?
+This is a scalar type that can also appear as the lane type of a SIMD vector.
+pub fn is_vector(self) -> boolIs this a SIMD vector type?
+A vector type has 2 or more lanes.
+pub fn is_bool(self) -> boolIs this a scalar boolean type?
+pub fn is_int(self) -> boolIs this a scalar integer type?
+pub fn is_float(self) -> boolIs this a scalar floating point type?
+pub fn is_flags(self) -> boolIs this a CPU flags type?
+pub fn is_ref(self) -> boolIs this a ref type?
+pub fn log2_lane_count(self) -> u8Get log_2 of the number of lanes in this SIMD vector type.
+All SIMD types have a lane count that is a power of two and no larger than 256, so this +will be a number in the range 0-8.
+A scalar type is the same as a SIMD vector type with one lane, so it returns 0.
+pub fn lane_count(self) -> u16Get the number of lanes in this SIMD vector type.
+A scalar type is the same as a SIMD vector type with one lane, so it returns 1.
+pub fn bits(self) -> u16Get the total number of bits used to represent this type.
+pub fn bytes(self) -> u32Get the number of bytes used to store this type in memory.
+pub fn by(self, n: u16) -> Option<Type>Get a SIMD vector type with n times more lanes than this one.
If this is a scalar type, this produces a SIMD type with this as a lane type and n lanes.
If this is already a SIMD vector type, this produces a SIMD vector type with n * self.lane_count() lanes.
pub fn half_vector(self) -> Option<Type>Get a SIMD vector with half the number of lanes.
+There is no double_vector() method. Use t.by(2) instead.
pub fn index(self) -> usizeIndex of this type, for use with hash tables etc.
+pub fn wider_or_equal(self, other: Type) -> boolTrue iff:
+self.lane_count() == other.lane_count() andself.lane_bits() >= other.lane_bits()pub fn triple_pointer_type(triple: &Triple) -> TypeReturn the pointer type for the given target triple.
+impl Clone for Typefn clone(&self) -> Typefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Typeimpl Debug for Typeimpl Default for Typeimpl Display for Typeimpl Eq for Typeimpl Hash for Typefn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Type> for Typeimpl StructuralEq for Typeimpl StructuralPartialEq for Typeimpl RefUnwindSafe for Typeimpl Send for Typeimpl Sync for Typeimpl Unpin for Typeimpl UnwindSafe for Typeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Marked with a label value.
+impl ValueLabelpub fn from_u32(x: u32) -> ValueLabelReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for ValueLabelfn clone(&self) -> ValueLabelfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for ValueLabelimpl Debug for ValueLabelimpl<'de> Deserialize<'de> for ValueLabelfn deserialize<__D>(
__deserializer: __D
) -> Result<ValueLabel, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Display for ValueLabelimpl EntityRef for ValueLabelfn new(index: usize) -> ValueLabelfn index(self) -> usizeimpl Eq for ValueLabelimpl Hash for ValueLabelfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<ValueLabel> for ValueLabelfn eq(&self, other: &ValueLabel) -> boolfn ne(&self, other: &ValueLabel) -> boolimpl ReservedValue for ValueLabelfn reserved_value() -> ValueLabelimpl Serialize for ValueLabelfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for ValueLabelimpl StructuralPartialEq for ValueLabelimpl RefUnwindSafe for ValueLabelimpl Send for ValueLabelimpl Sync for ValueLabelimpl Unpin for ValueLabelimpl UnwindSafe for ValueLabelimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type ValueLabelsRanges = HashMap<ValueLabel, Vec<ValueLocRange>, RandomState>;
Resulting map of Value labels and their ranges/locations.
+pub const B1: Type;
A boolean type with 1 bits.
+pub const B128: Type;
A boolean type with 128 bits.
+pub const B128X2: Type;
A SIMD vector with 2 lanes containing a b128 each.
pub const B128X4: Type;
A SIMD vector with 4 lanes containing a b128 each.
pub const B16: Type;
A boolean type with 16 bits.
+pub const B16X16: Type;
A SIMD vector with 16 lanes containing a b16 each.
pub const B16X32: Type;
A SIMD vector with 32 lanes containing a b16 each.
pub const B16X4: Type;
A SIMD vector with 4 lanes containing a b16 each.
pub const B16X8: Type;
A SIMD vector with 8 lanes containing a b16 each.
pub const B32: Type;
A boolean type with 32 bits.
+pub const B32X16: Type;
A SIMD vector with 16 lanes containing a b32 each.
pub const B32X2: Type;
A SIMD vector with 2 lanes containing a b32 each.
pub const B32X4: Type;
A SIMD vector with 4 lanes containing a b32 each.
pub const B32X8: Type;
A SIMD vector with 8 lanes containing a b32 each.
pub const B64: Type;
A boolean type with 64 bits.
+pub const B64X2: Type;
A SIMD vector with 2 lanes containing a b64 each.
pub const B64X4: Type;
A SIMD vector with 4 lanes containing a b64 each.
pub const B64X8: Type;
A SIMD vector with 8 lanes containing a b64 each.
pub const B8: Type;
A boolean type with 8 bits.
+pub const B8X16: Type;
A SIMD vector with 16 lanes containing a b8 each.
pub const B8X32: Type;
A SIMD vector with 32 lanes containing a b8 each.
pub const B8X64: Type;
A SIMD vector with 64 lanes containing a b8 each.
pub const B8X8: Type;
A SIMD vector with 8 lanes containing a b8 each.
pub const F32: Type;
A 32-bit floating point type represented in the IEEE 754-2008
+binary32 interchange format. This corresponds to the :c:type:float
+type in most C implementations.
pub const F32X16: Type;
A SIMD vector with 16 lanes containing a f32 each.
pub const F32X2: Type;
A SIMD vector with 2 lanes containing a f32 each.
pub const F32X4: Type;
A SIMD vector with 4 lanes containing a f32 each.
pub const F32X8: Type;
A SIMD vector with 8 lanes containing a f32 each.
pub const F64: Type;
A 64-bit floating point type represented in the IEEE 754-2008
+binary64 interchange format. This corresponds to the :c:type:double
+type in most C implementations.
pub const F64X2: Type;
A SIMD vector with 2 lanes containing a f64 each.
pub const F64X4: Type;
A SIMD vector with 4 lanes containing a f64 each.
pub const F64X8: Type;
A SIMD vector with 8 lanes containing a f64 each.
pub const FFLAGS: Type;
CPU flags representing the result of a floating point comparison. These
+flags can be tested with a :type:floatcc condition code.
pub const I128: Type;
An integer type with 128 bits.
+pub const I128X2: Type;
A SIMD vector with 2 lanes containing a i128 each.
pub const I128X4: Type;
A SIMD vector with 4 lanes containing a i128 each.
pub const I16: Type;
An integer type with 16 bits. +WARNING: arithmetic on 16bit integers is incomplete
+pub const I16X16: Type;
A SIMD vector with 16 lanes containing a i16 each.
pub const I16X32: Type;
A SIMD vector with 32 lanes containing a i16 each.
pub const I16X4: Type;
A SIMD vector with 4 lanes containing a i16 each.
pub const I16X8: Type;
A SIMD vector with 8 lanes containing a i16 each.
pub const I32: Type;
An integer type with 32 bits.
+pub const I32X16: Type;
A SIMD vector with 16 lanes containing a i32 each.
pub const I32X2: Type;
A SIMD vector with 2 lanes containing a i32 each.
pub const I32X4: Type;
A SIMD vector with 4 lanes containing a i32 each.
pub const I32X8: Type;
A SIMD vector with 8 lanes containing a i32 each.
pub const I64: Type;
An integer type with 64 bits.
+pub const I64X2: Type;
A SIMD vector with 2 lanes containing a i64 each.
pub const I64X4: Type;
A SIMD vector with 4 lanes containing a i64 each.
pub const I64X8: Type;
A SIMD vector with 8 lanes containing a i64 each.
pub const I8: Type;
An integer type with 8 bits. +WARNING: arithmetic on 8bit integers is incomplete
+pub const I8X16: Type;
A SIMD vector with 16 lanes containing a i8 each.
pub const I8X32: Type;
A SIMD vector with 32 lanes containing a i8 each.
pub const I8X64: Type;
A SIMD vector with 64 lanes containing a i8 each.
pub const I8X8: Type;
A SIMD vector with 8 lanes containing a i8 each.
pub const IFLAGS: Type;
CPU flags representing the result of an integer comparison. These flags
+can be tested with an :type:intcc condition code.
pub const INVALID: Type;
Not a valid type. Can't be loaded or stored. Can't be part of a SIMD vector.
+pub const R32: Type;
An opaque reference type with 32 bits.
+pub const R64: Type;
An opaque reference type with 64 bits.
+Common types for the Cranelift code generator.
+| Type | The type of an SSA value. + |
| B1 | A boolean type with 1 bits. + |
| B8 | A boolean type with 8 bits. + |
| B16 | A boolean type with 16 bits. + |
| B32 | A boolean type with 32 bits. + |
| B64 | A boolean type with 64 bits. + |
| B128 | A boolean type with 128 bits. + |
| B128X2 | A SIMD vector with 2 lanes containing a |
| B128X4 | A SIMD vector with 4 lanes containing a |
| B16X4 | A SIMD vector with 4 lanes containing a |
| B16X8 | A SIMD vector with 8 lanes containing a |
| B16X16 | A SIMD vector with 16 lanes containing a |
| B16X32 | A SIMD vector with 32 lanes containing a |
| B32X2 | A SIMD vector with 2 lanes containing a |
| B32X4 | A SIMD vector with 4 lanes containing a |
| B32X8 | A SIMD vector with 8 lanes containing a |
| B32X16 | A SIMD vector with 16 lanes containing a |
| B64X2 | A SIMD vector with 2 lanes containing a |
| B64X4 | A SIMD vector with 4 lanes containing a |
| B64X8 | A SIMD vector with 8 lanes containing a |
| B8X8 | A SIMD vector with 8 lanes containing a |
| B8X16 | A SIMD vector with 16 lanes containing a |
| B8X32 | A SIMD vector with 32 lanes containing a |
| B8X64 | A SIMD vector with 64 lanes containing a |
| F32 | A 32-bit floating point type represented in the IEEE 754-2008
+binary32 interchange format. This corresponds to the :c:type: |
| F64 | A 64-bit floating point type represented in the IEEE 754-2008
+binary64 interchange format. This corresponds to the :c:type: |
| F32X2 | A SIMD vector with 2 lanes containing a |
| F32X4 | A SIMD vector with 4 lanes containing a |
| F32X8 | A SIMD vector with 8 lanes containing a |
| F32X16 | A SIMD vector with 16 lanes containing a |
| F64X2 | A SIMD vector with 2 lanes containing a |
| F64X4 | A SIMD vector with 4 lanes containing a |
| F64X8 | A SIMD vector with 8 lanes containing a |
| FFLAGS | CPU flags representing the result of a floating point comparison. These
+flags can be tested with a :type: |
| I8 | An integer type with 8 bits. +WARNING: arithmetic on 8bit integers is incomplete + |
| I16 | An integer type with 16 bits. +WARNING: arithmetic on 16bit integers is incomplete + |
| I32 | An integer type with 32 bits. + |
| I64 | An integer type with 64 bits. + |
| I128 | An integer type with 128 bits. + |
| I128X2 | A SIMD vector with 2 lanes containing a |
| I128X4 | A SIMD vector with 4 lanes containing a |
| I16X4 | A SIMD vector with 4 lanes containing a |
| I16X8 | A SIMD vector with 8 lanes containing a |
| I16X16 | A SIMD vector with 16 lanes containing a |
| I16X32 | A SIMD vector with 32 lanes containing a |
| I32X2 | A SIMD vector with 2 lanes containing a |
| I32X4 | A SIMD vector with 4 lanes containing a |
| I32X8 | A SIMD vector with 8 lanes containing a |
| I32X16 | A SIMD vector with 16 lanes containing a |
| I64X2 | A SIMD vector with 2 lanes containing a |
| I64X4 | A SIMD vector with 4 lanes containing a |
| I64X8 | A SIMD vector with 8 lanes containing a |
| I8X8 | A SIMD vector with 8 lanes containing a |
| I8X16 | A SIMD vector with 16 lanes containing a |
| I8X32 | A SIMD vector with 32 lanes containing a |
| I8X64 | A SIMD vector with 64 lanes containing a |
| IFLAGS | CPU flags representing the result of an integer comparison. These flags
+can be tested with an :type: |
| INVALID | Not a valid type. Can't be loaded or stored. Can't be part of a SIMD vector. + |
| R32 | An opaque reference type with 32 bits. + |
| R64 | An opaque reference type with 64 bits. + |
The type of an SSA value.
+The INVALID type isn't a real type, and is used as a placeholder in the IR where a type
+field is present put no type is needed, such as the controlling type variable for a
+non-polymorphic instruction.
Basic integer types: I8, I16, I32, I64, and I128. These types are sign-agnostic.
Basic floating point types: F32 and F64. IEEE single and double precision.
Boolean types: B1, B8, B16, B32, B64, and B128. These all encode 'true' or 'false'. The
+larger types use redundant bits.
SIMD vector types have power-of-two lanes, up to 256. Lanes can be any int/float/bool type.
+impl Typepub fn lane_type(self) -> TypeGet the lane type of this SIMD vector type.
+A lane type is the same as a SIMD vector type with one lane, so it returns itself.
+pub fn lane_of(self) -> TypeThe type transformation that returns the lane type of a type variable; it is just a +renaming of lane_type() to be used in context where we think in terms of type variable +transformations.
+pub fn log2_lane_bits(self) -> u8Get log_2 of the number of bits in a lane.
+pub fn lane_bits(self) -> u8Get the number of bits in a lane.
+pub fn int(bits: u16) -> Option<Type>Get an integer type with the requested number of bits.
+pub fn as_bool_pedantic(self) -> TypeGet a type with the same number of lanes as this type, but with the lanes replaced by +booleans of the same size.
+Lane types are treated as vectors with one lane, so they are converted to the multi-bit +boolean types.
+pub fn as_bool(self) -> TypeGet a type with the same number of lanes as this type, but with the lanes replaced by +booleans of the same size.
+Scalar types are all converted to b1 which is usually what you want.
pub fn half_width(self) -> Option<Type>Get a type with the same number of lanes as this type, but with lanes that are half the +number of bits.
+pub fn double_width(self) -> Option<Type>Get a type with the same number of lanes as this type, but with lanes that are twice the +number of bits.
+pub fn is_invalid(self) -> boolIs this the INVALID type?
+pub fn is_special(self) -> boolIs this a special type?
+pub fn is_lane(self) -> boolIs this a lane type?
+This is a scalar type that can also appear as the lane type of a SIMD vector.
+pub fn is_vector(self) -> boolIs this a SIMD vector type?
+A vector type has 2 or more lanes.
+pub fn is_bool(self) -> boolIs this a scalar boolean type?
+pub fn is_int(self) -> boolIs this a scalar integer type?
+pub fn is_float(self) -> boolIs this a scalar floating point type?
+pub fn is_flags(self) -> boolIs this a CPU flags type?
+pub fn is_ref(self) -> boolIs this a ref type?
+pub fn log2_lane_count(self) -> u8Get log_2 of the number of lanes in this SIMD vector type.
+All SIMD types have a lane count that is a power of two and no larger than 256, so this +will be a number in the range 0-8.
+A scalar type is the same as a SIMD vector type with one lane, so it returns 0.
+pub fn lane_count(self) -> u16Get the number of lanes in this SIMD vector type.
+A scalar type is the same as a SIMD vector type with one lane, so it returns 1.
+pub fn bits(self) -> u16Get the total number of bits used to represent this type.
+pub fn bytes(self) -> u32Get the number of bytes used to store this type in memory.
+pub fn by(self, n: u16) -> Option<Type>Get a SIMD vector type with n times more lanes than this one.
If this is a scalar type, this produces a SIMD type with this as a lane type and n lanes.
If this is already a SIMD vector type, this produces a SIMD vector type with n * self.lane_count() lanes.
pub fn half_vector(self) -> Option<Type>Get a SIMD vector with half the number of lanes.
+There is no double_vector() method. Use t.by(2) instead.
pub fn index(self) -> usizeIndex of this type, for use with hash tables etc.
+pub fn wider_or_equal(self, other: Type) -> boolTrue iff:
+self.lane_count() == other.lane_count() andself.lane_bits() >= other.lane_bits()pub fn triple_pointer_type(triple: &Triple) -> TypeReturn the pointer type for the given target triple.
+impl Clone for Typefn clone(&self) -> Typefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Typeimpl Debug for Typeimpl Default for Typeimpl Display for Typeimpl Eq for Typeimpl Hash for Typefn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Type> for Typeimpl StructuralEq for Typeimpl StructuralPartialEq for Typeimpl RefUnwindSafe for Typeimpl Send for Typeimpl Sync for Typeimpl Unpin for Typeimpl UnwindSafe for Typeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Calling convention identifiers.
+Best performance, not ABI-stable
+Smallest caller code size, not ABI-stable
+System V-style convention used on many platforms
+Windows "fastcall" convention, also used for x64 and ARM
+SpiderMonkey WebAssembly convention on systems using natively SystemV
+SpiderMonkey WebAssembly convention on Windows
+Specialized convention for the probestack function
+impl CallConvpub fn triple_default(triple: &Triple) -> CallConvReturn the default calling convention for the given target triple.
+pub fn for_libcall(isa: &dyn TargetIsa) -> CallConvReturns the calling convention used for libcalls for the given ISA.
+pub fn extends_windows_fastcall(self) -> boolIs the calling convention extending the Windows Fastcall ABI?
+pub fn extends_baldrdash(self) -> boolIs the calling convention extending the Baldrdash ABI?
+impl Clone for CallConvfn clone(&self) -> CallConvfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for CallConvimpl Debug for CallConvimpl Display for CallConvimpl Eq for CallConvimpl FromStr for CallConvtype Err = ()The associated error which can be returned from parsing.
+fn from_str(s: &str) -> Result<CallConv, <CallConv as FromStr>::Err>impl Hash for CallConvfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<CallConv> for CallConvimpl StructuralEq for CallConvimpl StructuralPartialEq for CallConvimpl RefUnwindSafe for CallConvimpl Send for CallConvimpl Sync for CallConvimpl Unpin for CallConvimpl UnwindSafe for CallConvimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]| TargetFrontendConfig | This struct provides information that a frontend may need to know about a target to +produce Cranelift IR for the target. + |
| CallConv | Calling convention identifiers. + |
| TargetIsa | Methods that are specialized to a target ISA. Implies a Display trait that shows the +shared flags, as well as any isa-specific flags. + |
| RegUnit | Register units are the smallest units of register allocation. + |
This struct provides information that a frontend may need to know about a target to +produce Cranelift IR for the target.
+default_call_conv: CallConvThe default calling convention of the target.
+pointer_width: PointerWidthThe pointer width of the target.
+impl TargetFrontendConfigpub fn pointer_type(self) -> TypeGet the pointer type of this target.
+pub fn pointer_bits(self) -> u8Get the width of pointers on this target, in units of bits.
+pub fn pointer_bytes(self) -> u8Get the width of pointers on this target, in units of bytes.
+impl Clone for TargetFrontendConfigfn clone(&self) -> TargetFrontendConfigfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TargetFrontendConfigimpl RefUnwindSafe for TargetFrontendConfigimpl Send for TargetFrontendConfigimpl Sync for TargetFrontendConfigimpl Unpin for TargetFrontendConfigimpl UnwindSafe for TargetFrontendConfigimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Methods that are specialized to a target ISA. Implies a Display trait that shows the +shared flags, as well as any isa-specific flags.
+fn name(&self) -> &'static strGet the name of this ISA.
+fn triple(&self) -> &TripleGet the target triple that was used to make this trait object.
+fn flags(&self) -> &FlagsGet the ISA-independent flags that were used to make this trait object.
+fn register_info(&self) -> RegInfoGet a data structure describing the registers in this ISA.
+fn legal_encodings(
&'a self,
func: &'a Function,
inst: &'a InstructionData,
ctrl_typevar: Type
) -> Encodings<'a>Returns an iterator over legal encodings for the instruction.
+fn encoding_info(&self) -> EncInfoGet a data structure describing the instruction encodings in this ISA.
+fn legalize_signature(&self, sig: &mut Cow<Signature>, current: bool)Legalize a function signature.
+This is used to legalize both the signature of the function being compiled and any called
+functions. The signature should be modified by adding ArgumentLoc annotations to all
+arguments and return values.
Arguments with types that are not supported by the ABI can be expanded into multiple +arguments:
+The legalizer will adapt argument and return values as necessary at all ABI boundaries.
+When this function is called to legalize the signature of the function currently being
+compiled, current is true. The legalized signature can then also contain special purpose
+arguments and return values such as:
link argument representing the link registers on RISC architectures that don't push
+the return address on the stack.link return value which will receive the value that was passed to the link
+argument.sret argument can be added if one wasn't present already. This is necessary if the
+signature returns more values than registers are available for returning values.sret return value can be added if the ABI requires a function to return its sret
+argument in a register.Arguments and return values for the caller's frame pointer and other callee-saved registers +should not be added by this function. These arguments are not added until after register +allocation.
+fn regclass_for_abi_type(&self, ty: Type) -> &'static RegClassDataGet the register class that should be used to represent an ABI argument or return value of
+type ty. This should be the top-level register class that contains the argument
+registers.
This function can assume that it will only be asked to provide register classes for types
+that legalize_signature() produces in ArgumentLoc::Reg entries.
fn allocatable_registers(&self, func: &Function) -> RegisterSetGet the set of allocatable registers that can be used when compiling func.
This set excludes reserved registers like the stack pointer and other special-purpose +registers.
+fn emit_function_to_memory(&self, func: &Function, sink: &mut MemoryCodeSink)Emit a whole function into memory.
+fn unsigned_add_overflow_condition(&self) -> IntCCIntCC condition for Unsigned Addition Overflow (Carry).
+fn unsigned_sub_overflow_condition(&self) -> IntCCIntCC condition for Unsigned Subtraction Overflow (Borrow/Carry).
+fn default_call_conv(&self) -> CallConvGet the default calling convention of this target.
+fn pointer_type(&self) -> TypeGet the pointer type of this ISA.
+fn pointer_width(&self) -> PointerWidthGet the width of pointers on this ISA.
+fn pointer_bits(&self) -> u8Get the width of pointers on this ISA, in units of bits.
+fn pointer_bytes(&self) -> u8Get the width of pointers on this ISA, in units of bytes.
+fn frontend_config(&self) -> TargetFrontendConfigGet the information needed by frontends producing Cranelift IR.
+fn uses_cpu_flags(&self) -> boolDoes the CPU implement scalar comparisons using a CPU flags register?
+fn uses_complex_addresses(&self) -> boolDoes the CPU implement multi-register addressing?
+fn encode(
&self,
func: &Function,
inst: &InstructionData,
ctrl_typevar: Type
) -> Result<Encoding, fn(Inst, &mut Function, &mut ControlFlowGraph, &dyn TargetIsa) -> bool>Encode an instruction after determining it is legal.
+If inst can legally be encoded in this ISA, produce the corresponding Encoding object.
+Otherwise, return Legalize action.
This is also the main entry point for determining if an instruction is legal.
+fn prologue_epilogue(&self, func: &mut Function) -> Result<(), CodegenError>Compute the stack layout and insert prologue and epilogue code into func.
Return an error if the stack frame is too large.
+fn emit_unwind_info(
&self,
_func: &Function,
_kind: FrameUnwindKind,
_sink: &mut dyn FrameUnwindSink
)Emit unwind information for the given function.
+Only some calling conventions (e.g. Windows fastcall) will have unwind information.
+type RegUnit = u16;
Register units are the smallest units of register allocation.
+Normally there is a 1-1 correspondence between registers and register units, but when an ISA +has aliasing registers, the aliasing can be modeled with registers that cover multiple +register units.
+The register allocator will enforce that each register unit only gets used for one thing.
+Redirecting to ../../wasmtime_environ/enum.Export.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/enum.MemoryStyle.html b/api/wasmtime_environ/module/enum.MemoryStyle.html new file mode 100644 index 000000000000..0dcbd7ff12a7 --- /dev/null +++ b/api/wasmtime_environ/module/enum.MemoryStyle.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.MemoryStyle.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/enum.TableStyle.html b/api/wasmtime_environ/module/enum.TableStyle.html new file mode 100644 index 000000000000..af785eb16e5e --- /dev/null +++ b/api/wasmtime_environ/module/enum.TableStyle.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/enum.TableStyle.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/struct.MemoryPlan.html b/api/wasmtime_environ/module/struct.MemoryPlan.html new file mode 100644 index 000000000000..13ac466da897 --- /dev/null +++ b/api/wasmtime_environ/module/struct.MemoryPlan.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.MemoryPlan.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/struct.Module.html b/api/wasmtime_environ/module/struct.Module.html new file mode 100644 index 000000000000..9b213189643b --- /dev/null +++ b/api/wasmtime_environ/module/struct.Module.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.Module.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/struct.TableElements.html b/api/wasmtime_environ/module/struct.TableElements.html new file mode 100644 index 000000000000..5fa968c071f6 --- /dev/null +++ b/api/wasmtime_environ/module/struct.TableElements.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.TableElements.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module/struct.TablePlan.html b/api/wasmtime_environ/module/struct.TablePlan.html new file mode 100644 index 000000000000..1532731199d6 --- /dev/null +++ b/api/wasmtime_environ/module/struct.TablePlan.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.TablePlan.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/fn.translate_signature.html b/api/wasmtime_environ/module_environ/fn.translate_signature.html new file mode 100644 index 000000000000..040f415e7e4c --- /dev/null +++ b/api/wasmtime_environ/module_environ/fn.translate_signature.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/fn.translate_signature.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/struct.DataInitializer.html b/api/wasmtime_environ/module_environ/struct.DataInitializer.html new file mode 100644 index 000000000000..fc21eddafe5e --- /dev/null +++ b/api/wasmtime_environ/module_environ/struct.DataInitializer.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.DataInitializer.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/struct.DataInitializerLocation.html b/api/wasmtime_environ/module_environ/struct.DataInitializerLocation.html new file mode 100644 index 000000000000..580d73cb3adb --- /dev/null +++ b/api/wasmtime_environ/module_environ/struct.DataInitializerLocation.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.DataInitializerLocation.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/struct.FunctionBodyData.html b/api/wasmtime_environ/module_environ/struct.FunctionBodyData.html new file mode 100644 index 000000000000..3477ae9bb549 --- /dev/null +++ b/api/wasmtime_environ/module_environ/struct.FunctionBodyData.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.FunctionBodyData.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/struct.ModuleEnvironment.html b/api/wasmtime_environ/module_environ/struct.ModuleEnvironment.html new file mode 100644 index 000000000000..acde676352a3 --- /dev/null +++ b/api/wasmtime_environ/module_environ/struct.ModuleEnvironment.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.ModuleEnvironment.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/module_environ/struct.ModuleTranslation.html b/api/wasmtime_environ/module_environ/struct.ModuleTranslation.html new file mode 100644 index 000000000000..b04eb1d963db --- /dev/null +++ b/api/wasmtime_environ/module_environ/struct.ModuleTranslation.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.ModuleTranslation.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/settings/fn.builder.html b/api/wasmtime_environ/settings/fn.builder.html new file mode 100644 index 000000000000..6fa24c86b66c --- /dev/null +++ b/api/wasmtime_environ/settings/fn.builder.html @@ -0,0 +1,2 @@ +pub fn builder() -> Builder
Create a settings::Builder for the shared settings group.
| Builder | Collect settings values based on a template. + |
| Flags | Flags group |
| Configurable | A string-based configurator for settings groups. + |
| builder | Create a |
Collect settings values based on a template.
+impl Builderpub fn new(tmpl: &'static Template) -> BuilderCreate a new builder with defaults and names from the given template.
+pub fn state_for(self, name: &str) -> Box<[u8]>Extract contents of builder once everything is configured.
+impl Clone for Builderfn clone(&self) -> Builderfn clone_from(&mut self, source: &Self)1.0.0[src]impl Configurable for Builderimpl RefUnwindSafe for Builderimpl Send for Builderimpl Sync for Builderimpl Unpin for Builderimpl UnwindSafe for Builderimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Flags group shared.
impl Flagsimpl FlagsUser-defined settings.
+pub fn predicate_view(&self) -> PredicateViewGet a view of the boolean predicates.
+pub fn opt_level(&self) -> OptLevelOptimization level:
+pub fn libcall_call_conv(&self) -> LibcallCallConvDefines the calling convention to use for LibCalls call expansion, +since it may be different from the ISA default calling convention.
+The default value is to use the same calling convention as the ISA +default calling convention.
+This list should be kept in sync with the list of calling +conventions available in isa/call_conv.rs.
+pub fn baldrdash_prologue_words(&self) -> u8Number of pointer-sized words pushed by the baldrdash prologue.
+Functions with the baldrdash calling convention don't generate their
+own prologue and epilogue. They depend on externally generated code
+that pushes a fixed number of words in the prologue and restores them
+in the epilogue.
This setting configures the number of pointer-sized words pushed on the +stack when the Cranelift-generated code is entered. This includes the +pushed return address on x86.
+pub fn probestack_size_log2(&self) -> u8The log2 of the size of the stack guard region.
+Stack frames larger than this size will have stack overflow checked +by calling the probestack function.
+The default is 12, which translates to a size of 4096.
+pub fn enable_verifier(&self) -> boolRun the Cranelift IR verifier at strategic times during compilation.
+This makes compilation slower but catches many bugs. The verifier is always enabled by +default, which is useful during development.
+pub fn is_pic(&self) -> boolEnable Position-Independent Code generation
+pub fn use_colocated_libcalls(&self) -> boolUse colocated libcalls.
+Generate code that assumes that libcalls can be declared "colocated", +meaning they will be defined along with the current function, such that +they can use more efficient addressing.
+pub fn avoid_div_traps(&self) -> boolGenerate explicit checks around native division instructions to avoid +their trapping.
+This is primarily used by SpiderMonkey which doesn't install a signal +handler for SIGFPE, but expects a SIGILL trap for division by zero.
+On ISAs like ARM where the native division instructions don't trap, +this setting has no effect - explicit checks are always inserted.
+pub fn enable_float(&self) -> boolEnable the use of floating-point instructions
+Disabling use of floating-point instructions is not yet implemented.
+pub fn enable_nan_canonicalization(&self) -> boolEnable NaN canonicalization
+This replaces NaNs with a single canonical value, for users requiring +entirely deterministic WebAssembly computation. This is not required +by the WebAssembly spec, so it is not enabled by default.
+pub fn enable_pinned_reg(&self) -> boolEnable the use of the pinned register.
+This register is excluded from register allocation, and is completely under the control of +the end-user. It is possible to read it via the get_pinned_reg instruction, and to set it +with the set_pinned_reg instruction.
+pub fn use_pinned_reg_as_heap_base(&self) -> boolUse the pinned register as the heap base.
+Enabling this requires the enable_pinned_reg setting to be set to true. It enables a custom
+legalization of the heap_addr instruction so it will use the pinned register as the heap
+base, instead of fetching it from a global value.
Warning! Enabling this means that the pinned register must be maintained to contain the +heap base address at all times, during the lifetime of a function. Using the pinned +register for other purposes when this is set is very likely to cause crashes.
+pub fn enable_simd(&self) -> boolEnable the use of SIMD instructions.
+pub fn enable_atomics(&self) -> boolEnable the use of atomic instructions
+pub fn enable_safepoints(&self) -> boolEnable safepoint instruction insertions.
+This will allow the emit_stackmaps() function to insert the safepoint +instruction on top of calls and interrupt traps in order to display the +live reference values at that point in the program.
+pub fn emit_all_ones_funcaddrs(&self) -> boolEmit not-yet-relocated function addresses as all-ones bit patterns.
+pub fn enable_probestack(&self) -> boolEnable the use of stack probes, for calling conventions which support this +functionality.
+pub fn probestack_func_adjusts_sp(&self) -> boolSet this to true of the stack probe function modifies the stack pointer +itself.
+pub fn enable_jump_tables(&self) -> boolEnable the use of jump tables in generated machine code.
+impl Clone for Flagsfn clone(&self) -> Flagsfn clone_from(&mut self, source: &Self)1.0.0[src]impl Display for Flagsimpl RefUnwindSafe for Flagsimpl Send for Flagsimpl Sync for Flagsimpl Unpin for Flagsimpl UnwindSafe for Flagsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A string-based configurator for settings groups.
+The Configurable protocol allows settings to be modified by name before a finished Flags
+struct is created.
fn set(&mut self, name: &str, value: &str) -> Result<(), SetError>Set the string value of any setting by name.
+This can set any type of setting whether it is numeric, boolean, or enumerated.
+fn enable(&mut self, name: &str) -> Result<(), SetError>Enable a boolean setting or apply a preset.
+If the identified setting isn't a boolean or a preset, a BadType error is returned.
impl Configurable for Builderfn set(&mut self, name: &str, value: &str) -> Result<(), SetError>fn enable(&mut self, name: &str) -> Result<(), SetError>impl Configurable for wasmtime_environ::settings::BuilderAn index type for builtin functions.
+impl BuiltinFunctionIndex[src]pub const fn get_memory32_grow_index() -> Self[src]Returns an index for wasm's memory.grow builtin function.
pub const fn get_imported_memory32_grow_index() -> Self[src]Returns an index for wasm's imported memory.grow builtin function.
pub const fn get_memory32_size_index() -> Self[src]Returns an index for wasm's memory.size builtin function.
pub const fn get_imported_memory32_size_index() -> Self[src]Returns an index for wasm's imported memory.size builtin function.
pub const fn builtin_functions_total_number() -> u32[src]Returns the total number of builtin functions.
+pub const fn index(&self) -> u32[src]Return the index as an u32 number.
+impl RefUnwindSafe for BuiltinFunctionIndeximpl Send for BuiltinFunctionIndeximpl Sync for BuiltinFunctionIndeximpl Unpin for BuiltinFunctionIndeximpl UnwindSafe for BuiltinFunctionIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Global configuration for how the cache is managed
+impl CacheConfig[src]pub fn worker_event_queue_size(&self) -> u64[src]Returns $setting.
Panics if the cache is disabled.
+pub fn baseline_compression_level(&self) -> i32[src]Returns $setting.
Panics if the cache is disabled.
+pub fn optimized_compression_level(&self) -> i32[src]Returns $setting.
Panics if the cache is disabled.
+pub fn optimized_compression_usage_counter_threshold(&self) -> u64[src]Returns $setting.
Panics if the cache is disabled.
+pub fn cleanup_interval(&self) -> Duration[src]Returns $setting.
Panics if the cache is disabled.
+pub fn optimizing_compression_task_timeout(&self) -> Duration[src]Returns $setting.
Panics if the cache is disabled.
+pub fn allowed_clock_drift_for_files_from_future(&self) -> Duration[src]Returns $setting.
Panics if the cache is disabled.
+pub fn file_count_soft_limit(&self) -> u64[src]Returns $setting.
Panics if the cache is disabled.
+pub fn files_total_size_soft_limit(&self) -> u64[src]Returns $setting.
Panics if the cache is disabled.
+pub fn file_count_limit_percent_if_deleting(&self) -> u8[src]Returns $setting.
Panics if the cache is disabled.
+pub fn files_total_size_limit_percent_if_deleting(&self) -> u8[src]Returns $setting.
Panics if the cache is disabled.
+pub fn enabled(&self) -> bool[src]Returns true if and only if the cache is enabled.
+pub fn directory(&self) -> &PathBuf[src]Returns path to the cache directory.
+Panics if the cache is disabled.
+pub fn new_cache_disabled() -> Self[src]Creates a new set of configuration which represents a disabled cache
+pub fn from_file(config_file: Option<&Path>) -> Result<Self>[src]Parses cache configuration from the file specified
+impl Clone for CacheConfig[src]fn clone(&self) -> CacheConfig[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for CacheConfig[src]impl<'de> Deserialize<'de> for CacheConfig[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl RefUnwindSafe for CacheConfigimpl Send for CacheConfigimpl Sync for CacheConfigimpl Unpin for CacheConfigimpl UnwindSafe for CacheConfigimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The result of compiling a WebAssembly module's functions.
+impl Compilation[src]pub fn new(functions: PrimaryMap<DefinedFuncIndex, CompiledFunction>) -> Self[src]Creates a compilation artifact from a contiguous function buffer and a set of ranges
+pub fn from_buffer(
buffer: Vec<u8>,
functions: impl IntoIterator<Item = (Range<usize>, JumpTableOffsets, Range<usize>)>
) -> Self[src]Allocates the compilation result with the given function bodies.
+pub fn get(&self, func: DefinedFuncIndex) -> &CompiledFunction[src]Gets the bytes of a single function
+pub fn len(&self) -> usize[src]Gets the number of functions defined.
+pub fn is_empty(&self) -> bool[src]Returns whether there are no functions defined.
+pub fn get_jt_offsets(&self) -> PrimaryMap<DefinedFuncIndex, JumpTableOffsets>[src]Gets functions jump table offsets.
+impl Debug for Compilation[src]impl<'de> Deserialize<'de> for Compilation[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for Compilation[src]impl<'a> IntoIterator for &'a Compilation[src]type IntoIter = Iter<'a>Which kind of iterator are we turning this into?
+type Item = <Self::IntoIter as Iterator>::ItemThe type of the elements being iterated over.
+fn into_iter(self) -> Self::IntoIter[src]impl PartialEq<Compilation> for Compilation[src]fn eq(&self, other: &Compilation) -> bool[src]fn ne(&self, other: &Compilation) -> bool[src]impl Serialize for Compilation[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for Compilation[src]impl StructuralPartialEq for Compilation[src]impl RefUnwindSafe for Compilationimpl Send for Compilationimpl Sync for Compilationimpl Unpin for Compilationimpl UnwindSafe for Compilationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Compiled function: machine code body, jump table offsets, and unwind information.
+body: Vec<u8>The function body.
+jt_offsets: JumpTableOffsetsThe jump tables offsets (in the body).
+unwind_info: CompiledFunctionUnwindInfoThe unwind information.
+impl Clone for CompiledFunction[src]fn clone(&self) -> CompiledFunction[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for CompiledFunction[src]impl<'de> Deserialize<'de> for CompiledFunction[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for CompiledFunction[src]impl PartialEq<CompiledFunction> for CompiledFunction[src]fn eq(&self, other: &CompiledFunction) -> bool[src]fn ne(&self, other: &CompiledFunction) -> bool[src]impl Serialize for CompiledFunction[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for CompiledFunction[src]impl StructuralPartialEq for CompiledFunction[src]impl RefUnwindSafe for CompiledFunctionimpl Send for CompiledFunctionimpl Sync for CompiledFunctionimpl Unpin for CompiledFunctionimpl UnwindSafe for CompiledFunctionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Relocation entry for unwind info.
+offset: u32Entry offest in the code block.
+addend: u32Entry addend relative to the code block.
+impl Clone for CompiledFunctionUnwindInfoReloc[src]fn clone(&self) -> CompiledFunctionUnwindInfoReloc[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for CompiledFunctionUnwindInfoReloc[src]impl<'de> Deserialize<'de> for CompiledFunctionUnwindInfoReloc[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for CompiledFunctionUnwindInfoReloc[src]impl PartialEq<CompiledFunctionUnwindInfoReloc> for CompiledFunctionUnwindInfoReloc[src]fn eq(&self, other: &CompiledFunctionUnwindInfoReloc) -> bool[src]fn ne(&self, other: &CompiledFunctionUnwindInfoReloc) -> bool[src]impl Serialize for CompiledFunctionUnwindInfoReloc[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for CompiledFunctionUnwindInfoReloc[src]impl StructuralPartialEq for CompiledFunctionUnwindInfoReloc[src]impl RefUnwindSafe for CompiledFunctionUnwindInfoRelocimpl Send for CompiledFunctionUnwindInfoRelocimpl Sync for CompiledFunctionUnwindInfoRelocimpl Unpin for CompiledFunctionUnwindInfoRelocimpl UnwindSafe for CompiledFunctionUnwindInfoRelocimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A data initializer for linear memory.
+location: DataInitializerLocationThe location where the initialization is to be performed.
+data: &'data [u8]The initialization data.
+impl<'data> RefUnwindSafe for DataInitializer<'data>impl<'data> Send for DataInitializer<'data>impl<'data> Sync for DataInitializer<'data>impl<'data> Unpin for DataInitializer<'data>impl<'data> UnwindSafe for DataInitializer<'data>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A memory index and offset within that memory where a data initialization +should is to be performed.
+memory_index: MemoryIndexThe index of the memory to initialize.
+base: Option<GlobalIndex>Optionally a globalvar base to initialize at.
+offset: usizeA constant offset to initialize at.
+impl Clone for DataInitializerLocation[src]fn clone(&self) -> DataInitializerLocation[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl RefUnwindSafe for DataInitializerLocationimpl Send for DataInitializerLocationimpl Sync for DataInitializerLocationimpl Unpin for DataInitializerLocationimpl UnwindSafe for DataInitializerLocationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Function and its instructions addresses mappings.
+instructions: Vec<InstructionAddressMap>Instructions maps. +The array is sorted by the InstructionAddressMap::code_offset field.
+start_srcloc: SourceLocFunction start source location (normally declaration).
+end_srcloc: SourceLocFunction end source location.
+body_offset: usizeGenerated function body offset if applicable, otherwise 0.
+body_len: usizeGenerated function body length.
+impl Clone for FunctionAddressMap[src]fn clone(&self) -> FunctionAddressMap[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for FunctionAddressMap[src]impl<'de> Deserialize<'de> for FunctionAddressMap[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for FunctionAddressMap[src]impl PartialEq<FunctionAddressMap> for FunctionAddressMap[src]fn eq(&self, other: &FunctionAddressMap) -> bool[src]fn ne(&self, other: &FunctionAddressMap) -> bool[src]impl Serialize for FunctionAddressMap[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for FunctionAddressMap[src]impl StructuralPartialEq for FunctionAddressMap[src]impl RefUnwindSafe for FunctionAddressMapimpl Send for FunctionAddressMapimpl Sync for FunctionAddressMapimpl Unpin for FunctionAddressMapimpl UnwindSafe for FunctionAddressMapimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Contains function data: byte code and its offset in the module.
+data: &'a [u8]Body byte code.
+module_offset: usizeBody offset in the module file.
+impl<'a> Hash for FunctionBodyData<'a>[src]impl<'a> RefUnwindSafe for FunctionBodyData<'a>impl<'a> Send for FunctionBodyData<'a>impl<'a> Sync for FunctionBodyData<'a>impl<'a> Unpin for FunctionBodyData<'a>impl<'a> UnwindSafe for FunctionBodyData<'a>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Single source location to generated address mapping.
+srcloc: SourceLocOriginal source location.
+code_offset: usizeGenerated instructions offset.
+code_len: usizeGenerated instructions length.
+impl Clone for InstructionAddressMap[src]fn clone(&self) -> InstructionAddressMap[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for InstructionAddressMap[src]impl<'de> Deserialize<'de> for InstructionAddressMap[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for InstructionAddressMap[src]impl PartialEq<InstructionAddressMap> for InstructionAddressMap[src]fn eq(&self, other: &InstructionAddressMap) -> bool[src]fn ne(&self, other: &InstructionAddressMap) -> bool[src]impl Serialize for InstructionAddressMap[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for InstructionAddressMap[src]impl StructuralPartialEq for InstructionAddressMap[src]impl RefUnwindSafe for InstructionAddressMapimpl Send for InstructionAddressMapimpl Sync for InstructionAddressMapimpl Unpin for InstructionAddressMapimpl UnwindSafe for InstructionAddressMapimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly linear memory description along with our chosen style for +implementing it.
+memory: MemoryThe WebAssembly linear memory description.
+style: MemoryStyleOur chosen implementation style.
+offset_guard_size: u64Our chosen offset-guard size.
+impl MemoryPlan[src]pub fn for_memory(memory: Memory, tunables: &Tunables) -> Self[src]Draw up a plan for implementing a Memory.
impl Clone for MemoryPlan[src]fn clone(&self) -> MemoryPlan[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for MemoryPlan[src]impl Hash for MemoryPlan[src]impl RefUnwindSafe for MemoryPlanimpl Send for MemoryPlanimpl Sync for MemoryPlanimpl Unpin for MemoryPlanimpl UnwindSafe for MemoryPlanimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A translated WebAssembly module, excluding the function bodies and +memory initializers.
+id: usizeA unique identifier (within this process) for this module.
+signatures: PrimaryMap<SignatureIndex, Signature>Unprocessed signatures exactly as provided by declare_signature().
imported_funcs: PrimaryMap<FuncIndex, (String, String, u32)>Names of imported functions, as well as the index of the import that +performed this import.
+imported_tables: PrimaryMap<TableIndex, (String, String, u32)>Names of imported tables.
+imported_memories: PrimaryMap<MemoryIndex, (String, String, u32)>Names of imported memories.
+imported_globals: PrimaryMap<GlobalIndex, (String, String, u32)>Names of imported globals.
+functions: PrimaryMap<FuncIndex, SignatureIndex>Types of functions, imported and local.
+table_plans: PrimaryMap<TableIndex, TablePlan>WebAssembly tables.
+memory_plans: PrimaryMap<MemoryIndex, MemoryPlan>WebAssembly linear memory plans.
+globals: PrimaryMap<GlobalIndex, Global>WebAssembly global variables.
+exports: IndexMap<String, Export>Exported entities.
+start_func: Option<FuncIndex>The module "start" function, if present.
+table_elements: Vec<TableElements>WebAssembly table initializers.
+func_names: HashMap<FuncIndex, String>WebAssembly table initializers.
+impl Module[src]pub fn new() -> Self[src]Allocates the module data structures.
+pub fn func_index(&self, defined_func: DefinedFuncIndex) -> FuncIndex[src]Convert a DefinedFuncIndex into a FuncIndex.
pub fn defined_func_index(&self, func: FuncIndex) -> Option<DefinedFuncIndex>[src]Convert a FuncIndex into a DefinedFuncIndex. Returns None if the
+index is an imported function.
pub fn is_imported_function(&self, index: FuncIndex) -> bool[src]Test whether the given function index is for an imported function.
+pub fn table_index(&self, defined_table: DefinedTableIndex) -> TableIndex[src]Convert a DefinedTableIndex into a TableIndex.
pub fn defined_table_index(
&self,
table: TableIndex
) -> Option<DefinedTableIndex>[src]Convert a TableIndex into a DefinedTableIndex. Returns None if the
+index is an imported table.
pub fn is_imported_table(&self, index: TableIndex) -> bool[src]Test whether the given table index is for an imported table.
+pub fn memory_index(&self, defined_memory: DefinedMemoryIndex) -> MemoryIndex[src]Convert a DefinedMemoryIndex into a MemoryIndex.
pub fn defined_memory_index(
&self,
memory: MemoryIndex
) -> Option<DefinedMemoryIndex>[src]Convert a MemoryIndex into a DefinedMemoryIndex. Returns None if the
+index is an imported memory.
pub fn is_imported_memory(&self, index: MemoryIndex) -> bool[src]Test whether the given memory index is for an imported memory.
+pub fn global_index(&self, defined_global: DefinedGlobalIndex) -> GlobalIndex[src]Convert a DefinedGlobalIndex into a GlobalIndex.
pub fn defined_global_index(
&self,
global: GlobalIndex
) -> Option<DefinedGlobalIndex>[src]Convert a GlobalIndex into a DefinedGlobalIndex. Returns None if the
+index is an imported global.
pub fn is_imported_global(&self, index: GlobalIndex) -> bool[src]Test whether the given global index is for an imported global.
+pub fn hash_for_cache<'data, H>(
&self,
function_body_inputs: &PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
state: &mut H
) where
H: Hasher, [src]Computes hash of the module for the purpose of caching.
+impl RefUnwindSafe for Moduleimpl Send for Moduleimpl Sync for Moduleimpl Unpin for Moduleimpl UnwindSafe for Moduleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Object containing the standalone environment information.
+impl<'data> ModuleEnvironment<'data>[src]pub fn new(target_config: TargetFrontendConfig, tunables: Tunables) -> Self[src]Allocates the environment data structures.
+pub fn translate(
self,
data: &'data [u8]
) -> WasmResult<ModuleTranslation<'data>>[src]Translate a wasm module using this environment. This consumes the
+ModuleEnvironment and produces a ModuleTranslation.
impl<'data> ModuleEnvironment<'data> for ModuleEnvironment<'data>[src]This trait is useful for translate_module because it tells how to translate
+environment-dependent wasm instructions. These functions should not be called by the user.
fn reserve_signatures(&mut self, num: u32) -> WasmResult<()>[src]fn declare_signature(&mut self, sig: Signature) -> WasmResult<()>[src]fn declare_func_import(
&mut self,
sig_index: SignatureIndex,
module: &str,
field: &str
) -> WasmResult<()>[src]fn declare_table_import(
&mut self,
table: Table,
module: &str,
field: &str
) -> WasmResult<()>[src]fn declare_memory_import(
&mut self,
memory: Memory,
module: &str,
field: &str
) -> WasmResult<()>[src]fn declare_global_import(
&mut self,
global: Global,
module: &str,
field: &str
) -> WasmResult<()>[src]fn finish_imports(&mut self) -> WasmResult<()>[src]fn reserve_func_types(&mut self, num: u32) -> WasmResult<()>[src]fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()>[src]fn reserve_tables(&mut self, num: u32) -> WasmResult<()>[src]fn declare_table(&mut self, table: Table) -> WasmResult<()>[src]fn reserve_memories(&mut self, num: u32) -> WasmResult<()>[src]fn declare_memory(&mut self, memory: Memory) -> WasmResult<()>[src]fn reserve_globals(&mut self, num: u32) -> WasmResult<()>[src]fn declare_global(&mut self, global: Global) -> WasmResult<()>[src]fn reserve_exports(&mut self, num: u32) -> WasmResult<()>[src]fn declare_func_export(
&mut self,
func_index: FuncIndex,
name: &str
) -> WasmResult<()>[src]fn declare_table_export(
&mut self,
table_index: TableIndex,
name: &str
) -> WasmResult<()>[src]fn declare_memory_export(
&mut self,
memory_index: MemoryIndex,
name: &str
) -> WasmResult<()>[src]fn declare_global_export(
&mut self,
global_index: GlobalIndex,
name: &str
) -> WasmResult<()>[src]fn declare_start_func(&mut self, func_index: FuncIndex) -> WasmResult<()>[src]fn reserve_table_elements(&mut self, num: u32) -> WasmResult<()>[src]fn declare_table_elements(
&mut self,
table_index: TableIndex,
base: Option<GlobalIndex>,
offset: usize,
elements: Box<[FuncIndex]>
) -> WasmResult<()>[src]fn define_function_body(
&mut self,
_module_translation: &ModuleTranslationState,
body_bytes: &'data [u8],
body_offset: usize
) -> WasmResult<()>[src]fn reserve_data_initializers(&mut self, num: u32) -> WasmResult<()>[src]fn declare_data_initialization(
&mut self,
memory_index: MemoryIndex,
base: Option<GlobalIndex>,
offset: usize,
data: &'data [u8]
) -> WasmResult<()>[src]fn declare_func_name(
&mut self,
func_index: FuncIndex,
name: &'data str
) -> WasmResult<()>[src]fn reserve_imports(&mut self, _num: u32) -> Result<(), WasmError>fn finish_exports(&mut self) -> Result<(), WasmError>fn custom_section(
&mut self,
_name: &'data str,
_data: &'data [u8]
) -> Result<(), WasmError>impl<'data> TargetEnvironment for ModuleEnvironment<'data>[src]fn target_config(&self) -> TargetFrontendConfig[src]fn pointer_type(&self) -> Typefn pointer_bytes(&self) -> u8fn reference_type(&self) -> Typeimpl<'data> RefUnwindSafe for ModuleEnvironment<'data>impl<'data> Send for ModuleEnvironment<'data>impl<'data> Sync for ModuleEnvironment<'data>impl<'data> Unpin for ModuleEnvironment<'data>impl<'data> UnwindSafe for ModuleEnvironment<'data>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The result of translating via ModuleEnvironment. Function bodies are not
+yet translated, and data initializers have not yet been copied out of the
+original buffer.
target_config: TargetFrontendConfigCompilation setting flags.
+module: ModuleModule information.
+function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>References to the function bodies.
+data_initializers: Vec<DataInitializer<'data>>References to the data initializers.
+tunables: TunablesTunable parameters.
+module_translation: Option<ModuleTranslationState>The decoded Wasm types for the module.
+impl<'data> ModuleTranslation<'data>[src]pub fn func_env(&self) -> FuncEnvironment[src]Return a new FuncEnvironment for translating a function.
impl<'data> RefUnwindSafe for ModuleTranslation<'data>impl<'data> Send for ModuleTranslation<'data>impl<'data> Sync for ModuleTranslation<'data>impl<'data> Unpin for ModuleTranslation<'data>impl<'data> UnwindSafe for ModuleTranslation<'data>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Module vmctx related info.
memory_offset: ModuleMemoryOffsetThe memory definition offset in the VMContext structure.
+stack_slots: PrimaryMap<DefinedFuncIndex, StackSlots>The functions stack slots.
+impl Clone for ModuleVmctxInfo[src]fn clone(&self) -> ModuleVmctxInfo[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ModuleVmctxInfo[src]impl RefUnwindSafe for ModuleVmctxInfoimpl Send for ModuleVmctxInfoimpl Sync for ModuleVmctxInfoimpl Unpin for ModuleVmctxInfoimpl UnwindSafe for ModuleVmctxInfoimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A record of a relocation to perform.
+reloc: RelocThe relocation code.
+reloc_target: RelocationTargetRelocation target.
+offset: CodeOffsetThe offset where to apply the relocation.
+addend: AddendThe addend to add to the relocation value.
+impl Clone for Relocation[src]fn clone(&self) -> Relocation[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for Relocation[src]impl<'de> Deserialize<'de> for Relocation[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for Relocation[src]impl PartialEq<Relocation> for Relocation[src]fn eq(&self, other: &Relocation) -> bool[src]fn ne(&self, other: &Relocation) -> bool[src]impl Serialize for Relocation[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for Relocation[src]impl StructuralPartialEq for Relocation[src]impl RefUnwindSafe for Relocationimpl Send for Relocationimpl Sync for Relocationimpl Unpin for Relocationimpl UnwindSafe for Relocationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly table initializer.
+table_index: TableIndexThe index of a table to initialize.
+base: Option<GlobalIndex>Optionally, a global variable giving a base index.
+offset: usizeThe offset to add to the base.
+elements: Box<[FuncIndex]>The values to write into the table elements.
+impl Clone for TableElements[src]fn clone(&self) -> TableElements[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for TableElements[src]impl Hash for TableElements[src]impl RefUnwindSafe for TableElementsimpl Send for TableElementsimpl Sync for TableElementsimpl Unpin for TableElementsimpl UnwindSafe for TableElementsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly table description along with our chosen style for +implementing it.
+table: TableThe WebAssembly table description.
+style: TableStyleOur chosen implementation style.
+impl TablePlan[src]pub fn for_table(table: Table, tunables: &Tunables) -> Self[src]Draw up a plan for implementing a Table.
impl RefUnwindSafe for TablePlanimpl Send for TablePlanimpl Sync for TablePlanimpl Unpin for TablePlanimpl UnwindSafe for TablePlanimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Target specific type for shared signature index.
+impl TargetSharedSignatureIndex[src]pub fn new(value: u32) -> Self[src]Constructs TargetSharedSignatureIndex.
pub fn index(self) -> u32[src]Returns index value.
+impl Clone for TargetSharedSignatureIndex[src]fn clone(&self) -> TargetSharedSignatureIndex[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TargetSharedSignatureIndex[src]impl Debug for TargetSharedSignatureIndex[src]impl RefUnwindSafe for TargetSharedSignatureIndeximpl Send for TargetSharedSignatureIndeximpl Sync for TargetSharedSignatureIndeximpl Unpin for TargetSharedSignatureIndeximpl UnwindSafe for TargetSharedSignatureIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Information about trap.
+code_offset: CodeOffsetThe offset of the trapping instruction in native code. It is relative to the beginning of the function.
+source_loc: SourceLocLocation of trapping instruction in WebAssembly binary module.
+trap_code: TrapCodeCode of the trap.
+impl Debug for TrapInformation[src]impl<'de> Deserialize<'de> for TrapInformation[src]fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>, [src]impl Eq for TrapInformation[src]impl PartialEq<TrapInformation> for TrapInformation[src]fn eq(&self, other: &TrapInformation) -> bool[src]fn ne(&self, other: &TrapInformation) -> bool[src]impl Serialize for TrapInformation[src]fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
__S: Serializer, [src]impl StructuralEq for TrapInformation[src]impl StructuralPartialEq for TrapInformation[src]impl RefUnwindSafe for TrapInformationimpl Send for TrapInformationimpl Sync for TrapInformationimpl Unpin for TrapInformationimpl UnwindSafe for TrapInformationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Tunable parameters for WebAssembly compilation.
+static_memory_bound: u32For static heaps, the size in wasm pages of the heap protected by bounds checking.
+static_memory_offset_guard_size: u64The size in bytes of the offset guard for static heaps.
+dynamic_memory_offset_guard_size: u64The size in bytes of the offset guard for dynamic heaps.
+impl RefUnwindSafe for Tunablesimpl Send for Tunablesimpl Sync for Tunablesimpl Unpin for Tunablesimpl UnwindSafe for Tunablesimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]This class computes offsets to fields within VMContext and other
+related structs that JIT code accesses directly.
pointer_size: u8The size in bytes of a pointer on the target.
+num_signature_ids: u32The number of signature declarations in the module.
+num_imported_functions: u32The number of imported functions in the module.
+num_imported_tables: u32The number of imported tables in the module.
+num_imported_memories: u32The number of imported memories in the module.
+num_imported_globals: u32The number of imported globals in the module.
+num_defined_tables: u32The number of defined tables in the module.
+num_defined_memories: u32The number of defined memories in the module.
+num_defined_globals: u32The number of defined globals in the module.
+impl VMOffsets[src]pub fn new(pointer_size: u8, module: &Module) -> Self[src]Return a new VMOffsets instance, for a given pointer size.
impl VMOffsets[src]Offsets for VMFunctionImport.
pub fn vmfunction_import_body(&self) -> u8[src]The offset of the body field.
pub fn vmfunction_import_vmctx(&self) -> u8[src]The offset of the vmctx field.
pub fn size_of_vmfunction_import(&self) -> u8[src]Return the size of VMFunctionImport.
impl VMOffsets[src]Offsets for *const VMFunctionBody.
pub fn size_of_vmfunction_body_ptr(&self) -> u8[src]The size of the current_elements field.
impl VMOffsets[src]Offsets for VMTableImport.
pub fn vmtable_import_from(&self) -> u8[src]The offset of the from field.
pub fn vmtable_import_vmctx(&self) -> u8[src]The offset of the vmctx field.
pub fn size_of_vmtable_import(&self) -> u8[src]Return the size of VMTableImport.
impl VMOffsets[src]Offsets for VMTableDefinition.
pub fn vmtable_definition_base(&self) -> u8[src]The offset of the base field.
pub fn vmtable_definition_current_elements(&self) -> u8[src]The offset of the current_elements field.
pub fn size_of_vmtable_definition_current_elements(&self) -> u8[src]The size of the current_elements field.
pub fn size_of_vmtable_definition(&self) -> u8[src]Return the size of VMTableDefinition.
pub fn type_of_vmtable_definition_current_elements(&self) -> Type[src]The type of the current_elements field.
impl VMOffsets[src]Offsets for VMMemoryImport.
pub fn vmmemory_import_from(&self) -> u8[src]The offset of the from field.
pub fn vmmemory_import_vmctx(&self) -> u8[src]The offset of the vmctx field.
pub fn size_of_vmmemory_import(&self) -> u8[src]Return the size of VMMemoryImport.
impl VMOffsets[src]Offsets for VMMemoryDefinition.
pub fn vmmemory_definition_base(&self) -> u8[src]The offset of the base field.
pub fn vmmemory_definition_current_length(&self) -> u8[src]The offset of the current_length field.
pub fn size_of_vmmemory_definition_current_length(&self) -> u8[src]The size of the current_length field.
pub fn size_of_vmmemory_definition(&self) -> u8[src]Return the size of VMMemoryDefinition.
pub fn type_of_vmmemory_definition_current_length(&self) -> Type[src]The type of the current_length field.
impl VMOffsets[src]Offsets for VMGlobalImport.
pub fn vmglobal_import_from(&self) -> u8[src]The offset of the from field.
pub fn size_of_vmglobal_import(&self) -> u8[src]Return the size of VMGlobalImport.
impl VMOffsets[src]Offsets for VMGlobalDefinition.
pub fn size_of_vmglobal_definition(&self) -> u8[src]Return the size of VMGlobalDefinition; this is the size of the largest value type (i.e. a
+V128).
impl VMOffsets[src]Offsets for VMSharedSignatureIndex.
pub fn size_of_vmshared_signature_index(&self) -> u8[src]Return the size of VMSharedSignatureIndex.
impl VMOffsets[src]Offsets for VMCallerCheckedAnyfunc.
pub fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8[src]The offset of the func_ptr field.
pub fn vmcaller_checked_anyfunc_type_index(&self) -> u8[src]The offset of the type_index field.
pub fn vmcaller_checked_anyfunc_vmctx(&self) -> u8[src]The offset of the vmctx field.
pub fn size_of_vmcaller_checked_anyfunc(&self) -> u8[src]Return the size of VMCallerCheckedAnyfunc.
impl VMOffsets[src]Offsets for VMContext.
pub fn vmctx_signature_ids_begin(&self) -> u32[src]The offset of the signature_ids array.
pub fn vmctx_imported_functions_begin(&self) -> u32[src]The offset of the tables array.
pub fn vmctx_imported_tables_begin(&self) -> u32[src]The offset of the tables array.
pub fn vmctx_imported_memories_begin(&self) -> u32[src]The offset of the memories array.
pub fn vmctx_imported_globals_begin(&self) -> u32[src]The offset of the globals array.
pub fn vmctx_tables_begin(&self) -> u32[src]The offset of the tables array.
pub fn vmctx_memories_begin(&self) -> u32[src]The offset of the memories array.
pub fn vmctx_globals_begin(&self) -> u32[src]The offset of the globals array.
pub fn vmctx_builtin_functions_begin(&self) -> u32[src]The offset of the builtin functions array.
+pub fn size_of_vmctx(&self) -> u32[src]Return the size of the VMContext allocation.
pub fn vmctx_vmshared_signature_id(&self, index: SignatureIndex) -> u32[src]Return the offset to VMSharedSignatureId index index.
pub fn vmctx_vmfunction_import(&self, index: FuncIndex) -> u32[src]Return the offset to VMFunctionImport index index.
pub fn vmctx_vmtable_import(&self, index: TableIndex) -> u32[src]Return the offset to VMTableImport index index.
pub fn vmctx_vmmemory_import(&self, index: MemoryIndex) -> u32[src]Return the offset to VMMemoryImport index index.
pub fn vmctx_vmglobal_import(&self, index: GlobalIndex) -> u32[src]Return the offset to VMGlobalImport index index.
pub fn vmctx_vmtable_definition(&self, index: DefinedTableIndex) -> u32[src]Return the offset to VMTableDefinition index index.
pub fn vmctx_vmmemory_definition(&self, index: DefinedMemoryIndex) -> u32[src]Return the offset to VMMemoryDefinition index index.
pub fn vmctx_vmglobal_definition(&self, index: DefinedGlobalIndex) -> u32[src]Return the offset to the VMGlobalDefinition index index.
pub fn vmctx_vmfunction_import_body(&self, index: FuncIndex) -> u32[src]Return the offset to the body field in *const VMFunctionBody index index.
pub fn vmctx_vmfunction_import_vmctx(&self, index: FuncIndex) -> u32[src]Return the offset to the vmctx field in *const VMFunctionBody index index.
pub fn vmctx_vmtable_import_from(&self, index: TableIndex) -> u32[src]Return the offset to the from field in VMTableImport index index.
pub fn vmctx_vmtable_definition_base(&self, index: DefinedTableIndex) -> u32[src]Return the offset to the base field in VMTableDefinition index index.
pub fn vmctx_vmtable_definition_current_elements(
&self,
index: DefinedTableIndex
) -> u32[src]Return the offset to the current_elements field in VMTableDefinition index index.
pub fn vmctx_vmmemory_import_from(&self, index: MemoryIndex) -> u32[src]Return the offset to the from field in VMMemoryImport index index.
pub fn vmctx_vmmemory_import_vmctx(&self, index: MemoryIndex) -> u32[src]Return the offset to the vmctx field in VMMemoryImport index index.
pub fn vmctx_vmmemory_definition_base(&self, index: DefinedMemoryIndex) -> u32[src]Return the offset to the base field in VMMemoryDefinition index index.
pub fn vmctx_vmmemory_definition_current_length(
&self,
index: DefinedMemoryIndex
) -> u32[src]Return the offset to the current_length field in VMMemoryDefinition index index.
pub fn vmctx_vmglobal_import_from(&self, index: GlobalIndex) -> u32[src]Return the offset to the from field in VMGlobalImport index index.
pub fn vmctx_builtin_function(&self, index: BuiltinFunctionIndex) -> u32[src]Return the offset to builtin function in VMBuiltinFunctionsArray index index.
impl RefUnwindSafe for VMOffsetsimpl Send for VMOffsetsimpl Sync for VMOffsetsimpl Unpin for VMOffsetsimpl UnwindSafe for VMOffsetsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An implementation of a compiler from parsed WebAssembly module to native code.
+fn compile_module<'data, 'module>(
module: &'module Module,
module_translation: &ModuleTranslationState,
function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
isa: &dyn TargetIsa,
generate_debug_info: bool,
cache_config: &CacheConfig
) -> Result<(Compilation, Relocations, ModuleAddressMap, ValueLabelsRanges, PrimaryMap<DefinedFuncIndex, StackSlots>, Traps), CompileError>Compile a parsed module with the given TargetIsa.
impl Compiler for Cranelift[src]fn compile_module<'data, 'module>(
module: &'module Module,
module_translation: &ModuleTranslationState,
function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
isa: &dyn TargetIsa,
generate_debug_info: bool,
cache_config: &CacheConfig
) -> Result<(Compilation, Relocations, ModuleAddressMap, ValueLabelsRanges, PrimaryMap<DefinedFuncIndex, StackSlots>, Traps), CompileError>[src]Compile the module using Cranelift, producing a compilation result with +associated relocations.
+Redirecting to ../../wasmtime_environ/struct.Tunables.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/type.ModuleAddressMap.html b/api/wasmtime_environ/type.ModuleAddressMap.html new file mode 100644 index 000000000000..1148388ec6ff --- /dev/null +++ b/api/wasmtime_environ/type.ModuleAddressMap.html @@ -0,0 +1,2 @@ +type ModuleAddressMap = PrimaryMap<DefinedFuncIndex, FunctionAddressMap>;
Module functions addresses mappings.
+type Relocations = PrimaryMap<DefinedFuncIndex, Vec<Relocation>>;
Relocations to apply to function bodies.
+type Traps = PrimaryMap<DefinedFuncIndex, Vec<TrapInformation>>;
Information about traps associated with the functions where the traps are placed.
+type ValueLabelsRanges = PrimaryMap<DefinedFuncIndex, ValueLabelsRanges>;
Value ranges for functions.
+Redirecting to ../../wasmtime_environ/struct.TargetSharedSignatureIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/vmoffsets/struct.VMOffsets.html b/api/wasmtime_environ/vmoffsets/struct.VMOffsets.html new file mode 100644 index 000000000000..4392c211cd01 --- /dev/null +++ b/api/wasmtime_environ/vmoffsets/struct.VMOffsets.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_environ/struct.VMOffsets.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_environ/wasm/enum.GlobalInit.html b/api/wasmtime_environ/wasm/enum.GlobalInit.html new file mode 100644 index 000000000000..6d4ea1085ae1 --- /dev/null +++ b/api/wasmtime_environ/wasm/enum.GlobalInit.html @@ -0,0 +1,42 @@ +Globals are initialized via the const operators or by referring to another import.
I32Const(i32)An i32.const.
I64Const(i64)An i64.const.
F32Const(u32)An f32.const.
F64Const(u64)An f64.const.
A vconst.
GetGlobal(GlobalIndex)A global.get of another global.
A ref.null.
RefFunc(FuncIndex)A ref.func <index>.
< The global is imported from, and thus initialized by, a different module.
+impl Clone for GlobalInitfn clone(&self) -> GlobalInitfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for GlobalInitimpl Debug for GlobalInitimpl Hash for GlobalInitimpl RefUnwindSafe for GlobalInitimpl Send for GlobalInitimpl Sync for GlobalInitimpl Unpin for GlobalInitimpl UnwindSafe for GlobalInitimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]WebAssembly table element. Can be a function or a scalar type.
+Val(Type)A scalar type.
+A function.
+impl Clone for TableElementTypefn clone(&self) -> TableElementTypefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TableElementTypeimpl Debug for TableElementTypeimpl Hash for TableElementTypeimpl RefUnwindSafe for TableElementTypeimpl Send for TableElementTypeimpl Sync for TableElementTypeimpl Unpin for TableElementTypeimpl UnwindSafe for TableElementTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn get_vmctx_value_label() -> ValueLabel
Special VMContext value label. It is tracked as 0xffff_fffe label.
+| DefinedFuncIndex | Index type of a defined function inside the WebAssembly module. + |
| DefinedGlobalIndex | Index type of a defined global inside the WebAssembly module. + |
| DefinedMemoryIndex | Index type of a defined memory inside the WebAssembly module. + |
| DefinedTableIndex | Index type of a defined table inside the WebAssembly module. + |
| FuncIndex | Index type of a function (imported or defined) inside the WebAssembly module. + |
| Global | WebAssembly global. + |
| GlobalIndex | Index type of a global variable (imported or defined) inside the WebAssembly module. + |
| Memory | WebAssembly linear memory. + |
| MemoryIndex | Index type of a linear memory (imported or defined) inside the WebAssembly module. + |
| SignatureIndex | Index type of a signature (imported or defined) inside the WebAssembly module. + |
| Table | WebAssembly table. + |
| TableIndex | Index type of a table (imported or defined) inside the WebAssembly module. + |
| GlobalInit | Globals are initialized via the |
| TableElementType | WebAssembly table element. Can be a function or a scalar type. + |
| get_vmctx_value_label | Special VMContext value label. It is tracked as 0xffff_fffe label. + |
Index type of a defined function inside the WebAssembly module.
+impl DefinedFuncIndexpub fn from_u32(x: u32) -> DefinedFuncIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for DefinedFuncIndexfn clone(&self) -> DefinedFuncIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for DefinedFuncIndeximpl Debug for DefinedFuncIndeximpl EntityRef for DefinedFuncIndexfn new(index: usize) -> DefinedFuncIndexfn index(self) -> usizeimpl Eq for DefinedFuncIndeximpl Hash for DefinedFuncIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for DefinedFuncIndexfn cmp(&self, other: &DefinedFuncIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<DefinedFuncIndex> for DefinedFuncIndexfn eq(&self, other: &DefinedFuncIndex) -> boolfn ne(&self, other: &DefinedFuncIndex) -> boolimpl PartialOrd<DefinedFuncIndex> for DefinedFuncIndexfn partial_cmp(&self, other: &DefinedFuncIndex) -> Option<Ordering>fn lt(&self, other: &DefinedFuncIndex) -> boolfn le(&self, other: &DefinedFuncIndex) -> boolfn gt(&self, other: &DefinedFuncIndex) -> boolfn ge(&self, other: &DefinedFuncIndex) -> boolimpl ReservedValue for DefinedFuncIndexfn reserved_value() -> DefinedFuncIndeximpl StructuralEq for DefinedFuncIndeximpl StructuralPartialEq for DefinedFuncIndeximpl RefUnwindSafe for DefinedFuncIndeximpl Send for DefinedFuncIndeximpl Sync for DefinedFuncIndeximpl Unpin for DefinedFuncIndeximpl UnwindSafe for DefinedFuncIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a defined global inside the WebAssembly module.
+impl DefinedGlobalIndexpub fn from_u32(x: u32) -> DefinedGlobalIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for DefinedGlobalIndexfn clone(&self) -> DefinedGlobalIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for DefinedGlobalIndeximpl Debug for DefinedGlobalIndeximpl EntityRef for DefinedGlobalIndexfn new(index: usize) -> DefinedGlobalIndexfn index(self) -> usizeimpl Eq for DefinedGlobalIndeximpl Hash for DefinedGlobalIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for DefinedGlobalIndexfn cmp(&self, other: &DefinedGlobalIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<DefinedGlobalIndex> for DefinedGlobalIndexfn eq(&self, other: &DefinedGlobalIndex) -> boolfn ne(&self, other: &DefinedGlobalIndex) -> boolimpl PartialOrd<DefinedGlobalIndex> for DefinedGlobalIndexfn partial_cmp(&self, other: &DefinedGlobalIndex) -> Option<Ordering>fn lt(&self, other: &DefinedGlobalIndex) -> boolfn le(&self, other: &DefinedGlobalIndex) -> boolfn gt(&self, other: &DefinedGlobalIndex) -> boolfn ge(&self, other: &DefinedGlobalIndex) -> boolimpl ReservedValue for DefinedGlobalIndexfn reserved_value() -> DefinedGlobalIndeximpl StructuralEq for DefinedGlobalIndeximpl StructuralPartialEq for DefinedGlobalIndeximpl RefUnwindSafe for DefinedGlobalIndeximpl Send for DefinedGlobalIndeximpl Sync for DefinedGlobalIndeximpl Unpin for DefinedGlobalIndeximpl UnwindSafe for DefinedGlobalIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a defined memory inside the WebAssembly module.
+impl DefinedMemoryIndexpub fn from_u32(x: u32) -> DefinedMemoryIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for DefinedMemoryIndexfn clone(&self) -> DefinedMemoryIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for DefinedMemoryIndeximpl Debug for DefinedMemoryIndeximpl EntityRef for DefinedMemoryIndexfn new(index: usize) -> DefinedMemoryIndexfn index(self) -> usizeimpl Eq for DefinedMemoryIndeximpl Hash for DefinedMemoryIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for DefinedMemoryIndexfn cmp(&self, other: &DefinedMemoryIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<DefinedMemoryIndex> for DefinedMemoryIndexfn eq(&self, other: &DefinedMemoryIndex) -> boolfn ne(&self, other: &DefinedMemoryIndex) -> boolimpl PartialOrd<DefinedMemoryIndex> for DefinedMemoryIndexfn partial_cmp(&self, other: &DefinedMemoryIndex) -> Option<Ordering>fn lt(&self, other: &DefinedMemoryIndex) -> boolfn le(&self, other: &DefinedMemoryIndex) -> boolfn gt(&self, other: &DefinedMemoryIndex) -> boolfn ge(&self, other: &DefinedMemoryIndex) -> boolimpl ReservedValue for DefinedMemoryIndexfn reserved_value() -> DefinedMemoryIndeximpl StructuralEq for DefinedMemoryIndeximpl StructuralPartialEq for DefinedMemoryIndeximpl RefUnwindSafe for DefinedMemoryIndeximpl Send for DefinedMemoryIndeximpl Sync for DefinedMemoryIndeximpl Unpin for DefinedMemoryIndeximpl UnwindSafe for DefinedMemoryIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a defined table inside the WebAssembly module.
+impl DefinedTableIndexpub fn from_u32(x: u32) -> DefinedTableIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for DefinedTableIndexfn clone(&self) -> DefinedTableIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for DefinedTableIndeximpl Debug for DefinedTableIndeximpl EntityRef for DefinedTableIndexfn new(index: usize) -> DefinedTableIndexfn index(self) -> usizeimpl Eq for DefinedTableIndeximpl Hash for DefinedTableIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for DefinedTableIndexfn cmp(&self, other: &DefinedTableIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<DefinedTableIndex> for DefinedTableIndexfn eq(&self, other: &DefinedTableIndex) -> boolfn ne(&self, other: &DefinedTableIndex) -> boolimpl PartialOrd<DefinedTableIndex> for DefinedTableIndexfn partial_cmp(&self, other: &DefinedTableIndex) -> Option<Ordering>fn lt(&self, other: &DefinedTableIndex) -> boolfn le(&self, other: &DefinedTableIndex) -> boolfn gt(&self, other: &DefinedTableIndex) -> boolfn ge(&self, other: &DefinedTableIndex) -> boolimpl ReservedValue for DefinedTableIndexfn reserved_value() -> DefinedTableIndeximpl StructuralEq for DefinedTableIndeximpl StructuralPartialEq for DefinedTableIndeximpl RefUnwindSafe for DefinedTableIndeximpl Send for DefinedTableIndeximpl Sync for DefinedTableIndeximpl Unpin for DefinedTableIndeximpl UnwindSafe for DefinedTableIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a function (imported or defined) inside the WebAssembly module.
+impl FuncIndexpub fn from_u32(x: u32) -> FuncIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for FuncIndexfn clone(&self) -> FuncIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for FuncIndeximpl Debug for FuncIndeximpl<'de> Deserialize<'de> for FuncIndexfn deserialize<__D>(
__deserializer: __D
) -> Result<FuncIndex, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl EntityRef for FuncIndeximpl Eq for FuncIndeximpl Hash for FuncIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for FuncIndexfn cmp(&self, other: &FuncIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<FuncIndex> for FuncIndeximpl PartialOrd<FuncIndex> for FuncIndexfn partial_cmp(&self, other: &FuncIndex) -> Option<Ordering>fn lt(&self, other: &FuncIndex) -> boolfn le(&self, other: &FuncIndex) -> boolfn gt(&self, other: &FuncIndex) -> boolfn ge(&self, other: &FuncIndex) -> boolimpl ReservedValue for FuncIndexfn reserved_value() -> FuncIndeximpl Serialize for FuncIndexfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for FuncIndeximpl StructuralPartialEq for FuncIndeximpl RefUnwindSafe for FuncIndeximpl Send for FuncIndeximpl Sync for FuncIndeximpl Unpin for FuncIndeximpl UnwindSafe for FuncIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]WebAssembly global.
+ty: TypeThe type of the value stored in the global.
+mutability: boolA flag indicating whether the value may change at runtime.
+initializer: GlobalInitThe source of the initial value.
+impl Clone for Globalfn clone(&self) -> Globalfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Globalimpl Debug for Globalimpl Hash for Globalimpl RefUnwindSafe for Globalimpl Send for Globalimpl Sync for Globalimpl Unpin for Globalimpl UnwindSafe for Globalimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a global variable (imported or defined) inside the WebAssembly module.
+impl GlobalIndexpub fn from_u32(x: u32) -> GlobalIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for GlobalIndexfn clone(&self) -> GlobalIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for GlobalIndeximpl Debug for GlobalIndeximpl EntityRef for GlobalIndexfn new(index: usize) -> GlobalIndexfn index(self) -> usizeimpl Eq for GlobalIndeximpl Hash for GlobalIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for GlobalIndexfn cmp(&self, other: &GlobalIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<GlobalIndex> for GlobalIndexfn eq(&self, other: &GlobalIndex) -> boolfn ne(&self, other: &GlobalIndex) -> boolimpl PartialOrd<GlobalIndex> for GlobalIndexfn partial_cmp(&self, other: &GlobalIndex) -> Option<Ordering>fn lt(&self, other: &GlobalIndex) -> boolfn le(&self, other: &GlobalIndex) -> boolfn gt(&self, other: &GlobalIndex) -> boolfn ge(&self, other: &GlobalIndex) -> boolimpl ReservedValue for GlobalIndexfn reserved_value() -> GlobalIndeximpl StructuralEq for GlobalIndeximpl StructuralPartialEq for GlobalIndeximpl RefUnwindSafe for GlobalIndeximpl Send for GlobalIndeximpl Sync for GlobalIndeximpl Unpin for GlobalIndeximpl UnwindSafe for GlobalIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]WebAssembly linear memory.
+minimum: u32The minimum number of pages in the memory.
+maximum: Option<u32>The maximum number of pages in the memory.
+Whether the memory may be shared between multiple threads.
+impl Clone for Memoryfn clone(&self) -> Memoryfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Memoryimpl Debug for Memoryimpl Hash for Memoryimpl RefUnwindSafe for Memoryimpl Send for Memoryimpl Sync for Memoryimpl Unpin for Memoryimpl UnwindSafe for Memoryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a linear memory (imported or defined) inside the WebAssembly module.
+impl MemoryIndexpub fn from_u32(x: u32) -> MemoryIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for MemoryIndexfn clone(&self) -> MemoryIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for MemoryIndeximpl Debug for MemoryIndeximpl EntityRef for MemoryIndexfn new(index: usize) -> MemoryIndexfn index(self) -> usizeimpl Eq for MemoryIndeximpl Hash for MemoryIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for MemoryIndexfn cmp(&self, other: &MemoryIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<MemoryIndex> for MemoryIndexfn eq(&self, other: &MemoryIndex) -> boolfn ne(&self, other: &MemoryIndex) -> boolimpl PartialOrd<MemoryIndex> for MemoryIndexfn partial_cmp(&self, other: &MemoryIndex) -> Option<Ordering>fn lt(&self, other: &MemoryIndex) -> boolfn le(&self, other: &MemoryIndex) -> boolfn gt(&self, other: &MemoryIndex) -> boolfn ge(&self, other: &MemoryIndex) -> boolimpl ReservedValue for MemoryIndexfn reserved_value() -> MemoryIndeximpl StructuralEq for MemoryIndeximpl StructuralPartialEq for MemoryIndeximpl RefUnwindSafe for MemoryIndeximpl Send for MemoryIndeximpl Sync for MemoryIndeximpl Unpin for MemoryIndeximpl UnwindSafe for MemoryIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a signature (imported or defined) inside the WebAssembly module.
+impl SignatureIndexpub fn from_u32(x: u32) -> SignatureIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for SignatureIndexfn clone(&self) -> SignatureIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for SignatureIndeximpl Debug for SignatureIndeximpl EntityRef for SignatureIndexfn new(index: usize) -> SignatureIndexfn index(self) -> usizeimpl Eq for SignatureIndeximpl Hash for SignatureIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for SignatureIndexfn cmp(&self, other: &SignatureIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<SignatureIndex> for SignatureIndexfn eq(&self, other: &SignatureIndex) -> boolfn ne(&self, other: &SignatureIndex) -> boolimpl PartialOrd<SignatureIndex> for SignatureIndexfn partial_cmp(&self, other: &SignatureIndex) -> Option<Ordering>fn lt(&self, other: &SignatureIndex) -> boolfn le(&self, other: &SignatureIndex) -> boolfn gt(&self, other: &SignatureIndex) -> boolfn ge(&self, other: &SignatureIndex) -> boolimpl ReservedValue for SignatureIndexfn reserved_value() -> SignatureIndeximpl StructuralEq for SignatureIndeximpl StructuralPartialEq for SignatureIndeximpl RefUnwindSafe for SignatureIndeximpl Send for SignatureIndeximpl Sync for SignatureIndeximpl Unpin for SignatureIndeximpl UnwindSafe for SignatureIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]WebAssembly table.
+ty: TableElementTypeThe type of data stored in elements of the table.
+minimum: u32The minimum number of elements in the table.
+maximum: Option<u32>The maximum number of elements in the table.
+impl Clone for Tablefn clone(&self) -> Tablefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Tableimpl Debug for Tableimpl Hash for Tableimpl RefUnwindSafe for Tableimpl Send for Tableimpl Sync for Tableimpl Unpin for Tableimpl UnwindSafe for Tableimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Index type of a table (imported or defined) inside the WebAssembly module.
+impl TableIndexpub fn from_u32(x: u32) -> TableIndexReturn the underlying index value as a u32.
pub fn as_u32(self) -> u32Return the underlying index value as a u32.
impl Clone for TableIndexfn clone(&self) -> TableIndexfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TableIndeximpl Debug for TableIndeximpl EntityRef for TableIndexfn new(index: usize) -> TableIndexfn index(self) -> usizeimpl Eq for TableIndeximpl Hash for TableIndexfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl Ord for TableIndexfn cmp(&self, other: &TableIndex) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<TableIndex> for TableIndexfn eq(&self, other: &TableIndex) -> boolfn ne(&self, other: &TableIndex) -> boolimpl PartialOrd<TableIndex> for TableIndexfn partial_cmp(&self, other: &TableIndex) -> Option<Ordering>fn lt(&self, other: &TableIndex) -> boolfn le(&self, other: &TableIndex) -> boolfn gt(&self, other: &TableIndex) -> boolfn ge(&self, other: &TableIndex) -> boolimpl ReservedValue for TableIndexfn reserved_value() -> TableIndeximpl StructuralEq for TableIndeximpl StructuralPartialEq for TableIndeximpl RefUnwindSafe for TableIndeximpl Send for TableIndeximpl Sync for TableIndeximpl Unpin for TableIndeximpl UnwindSafe for TableIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> SparseMapValue<T> for T where
T: EntityRef, fn key(&self) -> Timpl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A call to one of Wasmtime's public APIs.
+ConfigDebugInfo(bool)id: usizewasm: WasmOptTtfid: usizeid: usizeimpl Arbitrary for ApiCall[src]fn arbitrary(u: &mut Unstructured) -> Result<Self>[src]fn arbitrary_take_rest(u: Unstructured) -> Result<Self>[src]fn size_hint() -> (usize, Option<usize>)[src]fn shrink(&self) -> Box<dyn Iterator<Item = Self>>[src]impl Clone for ApiCall[src]impl Debug for ApiCall[src]impl RefUnwindSafe for ApiCallimpl Send for ApiCallimpl Sync for ApiCallimpl Unpin for ApiCallimpl UnwindSafe for ApiCallimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Generating sequences of Wasmtime API calls.
+We only generate valid sequences of API calls. To do this, we keep track
+of what objects we've already created in earlier API calls via the Scope
+struct.
To generate even-more-pathological sequences of API calls, we use swarm +testing:
+++In swarm testing, the usual practice of potentially including all features +in every test case is abandoned. Rather, a large “swarm” of randomly +generated configurations, each of which omits some features, is used, with +configurations receiving equal resources.
+
| ApiCalls | A sequence of API calls. + |
| ApiCall | A call to one of Wasmtime's public APIs. + |
A sequence of API calls.
+calls: Vec<ApiCall>The API calls.
+impl Arbitrary for ApiCalls[src]fn arbitrary(input: &mut Unstructured) -> Result<Self>[src]fn arbitrary_take_rest(u: Unstructured) -> Result<Self, Error>fn size_hint() -> (usize, Option<usize>)fn shrink(&self) -> Box<dyn Iterator<Item = Self> + 'static>impl Debug for ApiCalls[src]impl RefUnwindSafe for ApiCallsimpl Send for ApiCallsimpl Sync for ApiCallsimpl Unpin for ApiCallsimpl UnwindSafe for ApiCallsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Test case generators.
+Test case generators take raw, unstructured input from a fuzzer +(e.g. libFuzzer) and translate that into a structured test case (e.g. a +valid Wasm binary).
+These are generally implementations of the Arbitrary trait, or some
+wrapper over an external tool, such that the wrapper implements the
+Arbitrary trait for the wrapped external tool.
| api | Generating sequences of Wasmtime API calls. + |
| DifferentialConfig | A description of configuration options that we should do differential +testing between. + |
| WasmOptTtf | A Wasm test case generator that is powered by Binaryen's |
A description of configuration options that we should do differential +testing between.
+impl DifferentialConfig[src]pub fn to_wasmtime_config(&self) -> Result<Config>[src]Convert this differential fuzzing config into a wasmtime::Config.
impl Arbitrary for DifferentialConfig[src]fn arbitrary(u: &mut Unstructured) -> Result<Self>[src]fn arbitrary_take_rest(u: Unstructured) -> Result<Self>[src]fn size_hint() -> (usize, Option<usize>)[src]fn shrink(&self) -> Box<dyn Iterator<Item = Self>>[src]impl Clone for DifferentialConfig[src]fn clone(&self) -> DifferentialConfig[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for DifferentialConfig[src]impl Eq for DifferentialConfig[src]impl Hash for DifferentialConfig[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<DifferentialConfig> for DifferentialConfig[src]fn eq(&self, other: &DifferentialConfig) -> bool[src]fn ne(&self, other: &DifferentialConfig) -> bool[src]impl StructuralEq for DifferentialConfig[src]impl StructuralPartialEq for DifferentialConfig[src]impl RefUnwindSafe for DifferentialConfigimpl Send for DifferentialConfigimpl Sync for DifferentialConfigimpl Unpin for DifferentialConfigimpl UnwindSafe for DifferentialConfigimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A Wasm test case generator that is powered by Binaryen's wasm-opt -ttf.
wasm: Vec<u8>The raw, encoded Wasm bytes.
+impl Arbitrary for WasmOptTtf[src]fn arbitrary(input: &mut Unstructured) -> Result<Self>[src]fn arbitrary_take_rest(input: Unstructured) -> Result<Self>[src]fn size_hint() -> (usize, Option<usize>)fn shrink(&self) -> Box<dyn Iterator<Item = Self> + 'static>impl Clone for WasmOptTtf[src]fn clone(&self) -> WasmOptTtf[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for WasmOptTtf[src]impl RefUnwindSafe for WasmOptTtfimpl Send for WasmOptTtfimpl Sync for WasmOptTtfimpl Unpin for WasmOptTtfimpl UnwindSafe for WasmOptTtfimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Fuzzing infrastructure for Wasmtime.
+| generators | Test case generators. + |
| oracles | Oracles. + |
pub fn dummy_global(store: &Store, ty: GlobalType) -> Result<Global, Trap>
Construct a dummy global for the given global type.
+pub fn dummy_imports(
store: &Store,
import_tys: &[ImportType]
) -> Result<Vec<Extern>, Trap>
Create a set of dummy functions/globals/etc for the given imports.
+pub fn dummy_memory(store: &Store, ty: MemoryType) -> Memory
Construct a dummy memory for the given memory type.
+pub fn dummy_table(store: &Store, ty: TableType) -> Result<Table, Trap>
Construct a dummy table for the given table type.
+pub fn dummy_value(val_ty: &ValType) -> Result<Val, Trap>
Construct a dummy value for the given value type.
+pub fn dummy_values(val_tys: &[ValType]) -> Result<Vec<Val>, Trap>
Construct a sequence of dummy values for the given types.
+Dummy implementations of things that a Wasm module can import.
+| DummyFunc | A function that doesn't do anything but return the default (zero) value for +the function's type. + |
| dummy_global | Construct a dummy global for the given global type. + |
| dummy_imports | Create a set of dummy functions/globals/etc for the given imports. + |
| dummy_memory | Construct a dummy memory for the given memory type. + |
| dummy_table | Construct a dummy table for the given table type. + |
| dummy_value | Construct a dummy value for the given value type. + |
| dummy_values | Construct a sequence of dummy values for the given types. + |
A function that doesn't do anything but return the default (zero) value for +the function's type.
+impl DummyFunc[src]impl RefUnwindSafe for DummyFuncimpl Send for DummyFuncimpl Sync for DummyFuncimpl Unpin for DummyFuncimpl UnwindSafe for DummyFuncimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn compile(wasm: &[u8], strategy: Strategy)
Compile the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively".
+Performs initial validation, and returns early if the Wasm is invalid.
+You can control which compiler is used via passing a Strategy.
pub fn differential_execution(ttf: &WasmOptTtf, configs: &[DifferentialConfig])
Instantiate the given Wasm module with each Config and call all of its
+exports. Modulo OOM, non-canonical NaNs, and usage of Wasm features that are
+or aren't enabled for different configs, we should get the same results when
+we call the exported functions for all of our different configs.
pub fn instantiate(wasm: &[u8], strategy: Strategy)
Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively".
+Performs initial validation, and returns early if the Wasm is invalid.
+You can control which compiler is used via passing a Strategy.
pub fn instantiate_with_config(wasm: &[u8], config: Config)
Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively".
+The engine will be configured using provided config.
+See also instantiate functions.
pub fn make_api_calls(api: ApiCalls)
Invoke the given API calls.
+Oracles.
+Oracles take a test case and determine whether we have a bug. For example, +one of the simplest oracles is to take a Wasm binary as our input test case, +validate and instantiate it, and (implicitly) check that no assertions +failed or segfaults happened. A more complicated oracle might compare the +result of executing a Wasm file with and without optimizations enabled, and +make sure that the two executions are observably identical.
+When an oracle finds a bug, it should report it to the fuzzing engine by +panicking.
+| dummy | Dummy implementations of things that a Wasm module can import. + |
| compile | Compile the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively". + |
| differential_execution | Instantiate the given Wasm module with each |
| instantiate | Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively". + |
| instantiate_with_config | Instantiate the Wasm buffer, and implicitly fail if we have an unexpected +panic or segfault or anything else that can be detected "passively". + |
| make_api_calls | Invoke the given API calls. + |
The set of all possible WebAssembly Interface Types
+String(String)I32(i32)U32(u32)I64(i64)U64(u64)F32(f32)F64(f64)impl Clone for Value[src]impl Debug for Value[src]impl Display for Value[src]impl<'a> From<&'a str> for Value[src]impl From<String> for Value[src]impl From<f32> for Value[src]impl From<f64> for Value[src]impl From<i32> for Value[src]impl From<i64> for Value[src]impl From<u32> for Value[src]impl From<u64> for Value[src]impl TryFrom<Value> for String[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<String, Self::Error>[src]impl TryFrom<Value> for i32[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<i32, Self::Error>[src]impl TryFrom<Value> for u32[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<u32, Self::Error>[src]impl TryFrom<Value> for i64[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<i64, Self::Error>[src]impl TryFrom<Value> for u64[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<u64, Self::Error>[src]impl TryFrom<Value> for f32[src]type Error = ErrorThe type returned in the event of a conversion error.
+fn try_from(val: Value) -> Result<f32, Self::Error>[src]impl TryFrom<Value> for f64[src]impl RefUnwindSafe for Valueimpl Send for Valueimpl Sync for Valueimpl Unpin for Valueimpl UnwindSafe for Valueimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A small crate to handle WebAssembly interface types in wasmtime.
+Note that this is intended to follow the official proposal and +is highly susceptible to change/breakage/etc.
+| ExportBinding | Representation of a binding of an exported function. + |
| ModuleData | A data structure intended to hold a parsed representation of the wasm +interface types of a module. + |
| Value | The set of all possible WebAssembly Interface Types + |
Representation of a binding of an exported function.
+Can be used to learn about binding expressions and/or binding types.
+impl<'_> ExportBinding<'_>[src]pub fn param_bindings(&self) -> Result<Vec<IncomingBindingExpression>>[src]Returns the list of binding expressions used to create the parameters +for this binding.
+pub fn param_types(&self) -> Result<Vec<WebidlScalarType>>[src]Returns the list of scalar types used for this binding
+pub fn result_bindings(&self) -> Result<Vec<OutgoingBindingExpression>>[src]Returns the list of binding expressions used to extract the return +values of this binding.
+impl<'a> RefUnwindSafe for ExportBinding<'a>impl<'a> Send for ExportBinding<'a>impl<'a> Sync for ExportBinding<'a>impl<'a> Unpin for ExportBinding<'a>impl<'a> UnwindSafe for ExportBinding<'a>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A data structure intended to hold a parsed representation of the wasm +interface types of a module.
+The expected usage pattern is to create this next to wasmtime data +structures and then use this to process arguments into wasm arguments as +appropriate for bound functions.
+impl ModuleData[src]pub fn new(wasm: &[u8]) -> Result<ModuleData>[src]Parses a raw binary wasm file, extracting information about wasm +interface types.
+Returns an error if the wasm file is malformed.
+pub fn find_wasi_module_name(&self) -> Option<String>[src]Detects if WASI support is needed: returns module name that is requested.
+pub fn invoke_export(
&self,
instance: &Instance,
export: &str,
args: &[Value]
) -> Result<Vec<Value>>[src]Invokes wasmtime function with a &[Value] list. Value the set of
+wasm interface types.
pub fn binding_for_export(
&self,
instance: &mut InstanceHandle,
name: &str
) -> Result<ExportBinding>[src]Returns an appropriate binding for the name export in this module
+which has also been instantiated as instance provided here.
Returns an error if name is not present in the module.
impl !RefUnwindSafe for ModuleDataimpl Send for ModuleDataimpl Sync for ModuleDataimpl Unpin for ModuleDataimpl !UnwindSafe for ModuleDataimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime_interface_types/enum.Value.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/all.html b/api/wasmtime_jit/all.html new file mode 100644 index 000000000000..5381a88baf7b --- /dev/null +++ b/api/wasmtime_jit/all.html @@ -0,0 +1,3 @@ +Redirecting to ../../wasmtime_jit/struct.CodeMemory.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/compiler/enum.CompilationStrategy.html b/api/wasmtime_jit/compiler/enum.CompilationStrategy.html new file mode 100644 index 000000000000..a56336871635 --- /dev/null +++ b/api/wasmtime_jit/compiler/enum.CompilationStrategy.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/enum.CompilationStrategy.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/compiler/struct.Compiler.html b/api/wasmtime_jit/compiler/struct.Compiler.html new file mode 100644 index 000000000000..2ec3ce855131 --- /dev/null +++ b/api/wasmtime_jit/compiler/struct.Compiler.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/struct.Compiler.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/constant.VERSION.html b/api/wasmtime_jit/constant.VERSION.html new file mode 100644 index 000000000000..d193d5cf3d82 --- /dev/null +++ b/api/wasmtime_jit/constant.VERSION.html @@ -0,0 +1,2 @@ +pub const VERSION: &str = env!("CARGO_PKG_VERSION");
Version number of this crate.
+Select which kind of compilation to use.
+Let Wasmtime pick the strategy.
+Compile all functions with Cranelift.
+impl Clone for CompilationStrategy[src]fn clone(&self) -> CompilationStrategy[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for CompilationStrategy[src]impl Debug for CompilationStrategy[src]impl RefUnwindSafe for CompilationStrategyimpl Send for CompilationStrategyimpl Sync for CompilationStrategyimpl Unpin for CompilationStrategyimpl UnwindSafe for CompilationStrategyimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error while instantiating a module.
+Resource(String)Insufficient resources available for execution.
+Link(LinkError)A wasm link error occured.
+StartTrap(Trap)A compilation error occured.
+impl Debug for InstantiationError[src]impl Display for InstantiationError[src]impl Error for InstantiationError[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<InstantiationError> for SetupError[src]fn from(source: InstantiationError) -> Self[src]impl From<LinkError> for InstantiationError[src]fn from(source: LinkError) -> InstantiationError[src]impl !RefUnwindSafe for InstantiationErrorimpl Send for InstantiationErrorimpl Sync for InstantiationErrorimpl Unpin for InstantiationErrorimpl !UnwindSafe for InstantiationErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error condition while setting up a wasm instance, be it validation, +compilation, or instantiation.
+Validate(String)The module did not pass validation.
+Compile(CompileError)A wasm translation error occured.
+Instantiate(InstantiationError)Some runtime resource was unavailable or insufficient, or the start function +trapped.
+DebugInfo(Error)Debug information generation error occured.
+impl Debug for SetupError[src]impl Display for SetupError[src]impl Error for SetupError[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<CompileError> for SetupError[src]fn from(source: CompileError) -> Self[src]impl From<Error> for SetupError[src]impl From<InstantiationError> for SetupError[src]fn from(source: InstantiationError) -> Self[src]impl !RefUnwindSafe for SetupErrorimpl Send for SetupErrorimpl Sync for SetupErrorimpl Unpin for SetupErrorimpl !UnwindSafe for SetupErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub unsafe fn instantiate(
compiler: &mut Compiler,
data: &[u8],
resolver: &mut dyn Resolver,
debug_info: bool
) -> Result<InstanceHandle, SetupError>
Create a new wasm instance by compiling the wasm module in data and instatiating it.
This is equivalent to createing a CompiledModule and calling instantiate() on it,
+but avoids creating an intermediate copy of the data initializers.
See InstanceHandle::new
pub fn link_module(
module: &Module,
allocated_functions: &PrimaryMap<DefinedFuncIndex, *mut [VMFunctionBody]>,
jt_offsets: &PrimaryMap<DefinedFuncIndex, JumpTableOffsets>,
relocations: Relocations
)
Links a module that has been compiled with compiled_module in wasmtime-environ.
Performs all required relocations inside the function code, provided the necessary metadata.
+pub fn target_tunables(triple: &Triple) -> Tunables
Return a Tunables instance tuned for the given target platform.
JIT-style runtime for WebAssembly using Cranelift.
+| native | |
| trampoline |
| CodeMemory | Memory manager for executable code. + |
| CompiledModule | A compiled wasm module, ready to be instantiated. + |
| Compiler | A WebAssembly code JIT compiler. + |
| InstanceHandle | A handle holding an |
| NullResolver |
|
| CompilationStrategy | Select which kind of compilation to use. + |
| InstantiationError | An error while instantiating a module. + |
| SetupError | An error condition while setting up a wasm instance, be it validation, +compilation, or instantiation. + |
| VERSION | Version number of this crate. + |
| Resolver | Import resolver connects imports with available exported values. + |
| instantiate⚠ | Create a new wasm instance by compiling the wasm module in |
| link_module | Links a module that has been compiled with |
| target_tunables | Return a |
Redirecting to ../../wasmtime_jit/enum.SetupError.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/instantiate/fn.instantiate.html b/api/wasmtime_jit/instantiate/fn.instantiate.html new file mode 100644 index 000000000000..b1cc3abbc255 --- /dev/null +++ b/api/wasmtime_jit/instantiate/fn.instantiate.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/fn.instantiate.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/instantiate/struct.CompiledModule.html b/api/wasmtime_jit/instantiate/struct.CompiledModule.html new file mode 100644 index 000000000000..b182e5408a1d --- /dev/null +++ b/api/wasmtime_jit/instantiate/struct.CompiledModule.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/struct.CompiledModule.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/link/fn.link_module.html b/api/wasmtime_jit/link/fn.link_module.html new file mode 100644 index 000000000000..955151b83785 --- /dev/null +++ b/api/wasmtime_jit/link/fn.link_module.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/fn.link_module.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/native/fn.builder.html b/api/wasmtime_jit/native/fn.builder.html new file mode 100644 index 000000000000..d221b9c1a10e --- /dev/null +++ b/api/wasmtime_jit/native/fn.builder.html @@ -0,0 +1 @@ +pub fn builder() -> Builder
pub fn call_conv() -> CallConv
pub fn lookup(triple: Triple) -> Result<Builder, LookupError>
Look for an ISA for the given triple.
+Return a builder that can create a corresponding TargetIsa.
| builder | |
| call_conv | |
| lookup | Look for an ISA for the given |
Redirecting to ../../wasmtime_jit/struct.NullResolver.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/resolver/trait.Resolver.html b/api/wasmtime_jit/resolver/trait.Resolver.html new file mode 100644 index 000000000000..417f5cb20806 --- /dev/null +++ b/api/wasmtime_jit/resolver/trait.Resolver.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_jit/trait.Resolver.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/sidebar-items.js b/api/wasmtime_jit/sidebar-items.js new file mode 100644 index 000000000000..f712042d2694 --- /dev/null +++ b/api/wasmtime_jit/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"constant":[["VERSION","Version number of this crate."]],"enum":[["CompilationStrategy","Select which kind of compilation to use."],["InstantiationError","An error while instantiating a module."],["SetupError","An error condition while setting up a wasm instance, be it validation, compilation, or instantiation."]],"fn":[["instantiate","Create a new wasm instance by compiling the wasm module in `data` and instatiating it."],["link_module","Links a module that has been compiled with `compiled_module` in `wasmtime-environ`."],["target_tunables","Return a `Tunables` instance tuned for the given target platform."]],"mod":[["native",""],["trampoline",""]],"struct":[["CodeMemory","Memory manager for executable code."],["CompiledModule","A compiled wasm module, ready to be instantiated."],["Compiler","A WebAssembly code JIT compiler."],["InstanceHandle","A handle holding an `Instance` of a WebAssembly module."],["NullResolver","`Resolver` implementation that always resolves to `None`."]],"trait":[["Resolver","Import resolver connects imports with available exported values."]]}); \ No newline at end of file diff --git a/api/wasmtime_jit/struct.CodeMemory.html b/api/wasmtime_jit/struct.CodeMemory.html new file mode 100644 index 000000000000..04ed3ec1ca7b --- /dev/null +++ b/api/wasmtime_jit/struct.CodeMemory.html @@ -0,0 +1,19 @@ +Memory manager for executable code.
+impl CodeMemory[src]pub fn new() -> Self[src]Create a new CodeMemory instance.
pub fn allocate_for_function(
&mut self,
func: &CompiledFunction
) -> Result<&mut [VMFunctionBody], String>[src]Allocate a continuous memory block for a single compiled function. +TODO: Reorganize the code that calls this to emit code directly into the +mmap region rather than into a Vec that we need to copy in.
+pub fn allocate_for_compilation(
&mut self,
compilation: &Compilation
) -> Result<Box<[&mut [VMFunctionBody]]>, String>[src]Allocate a continuous memory block for a compilation.
+Allocates memory for both the function bodies as well as function unwind data.
+pub fn publish(&mut self)[src]Make all allocated memory executable.
+impl RefUnwindSafe for CodeMemoryimpl Send for CodeMemoryimpl Sync for CodeMemoryimpl Unpin for CodeMemoryimpl UnwindSafe for CodeMemoryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A compiled wasm module, ready to be instantiated.
+impl CompiledModule[src]pub fn new<'data>(
compiler: &mut Compiler,
data: &'data [u8],
debug_info: bool
) -> Result<Self, SetupError>[src]Compile a data buffer into a CompiledModule, which may then be instantiated.
pub fn from_parts(
module: Module,
finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>,
data_initializers: Box<[OwnedDataInitializer]>,
signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
dbg_jit_registration: Option<GdbJitImageRegistration>,
trap_registration: TrapRegistration
) -> Self[src]Construct a CompiledModule from component parts.
pub unsafe fn instantiate(
&self,
resolver: &mut dyn Resolver
) -> Result<InstanceHandle, InstantiationError>[src]Crate an Instance from this CompiledModule.
Note that if only one instance of this module is needed, it may be more
+efficient to call the top-level instantiate, since that avoids copying
+the data initializers.
See InstanceHandle::new
pub fn module(&self) -> &Arc<Module>[src]Return a reference-counting pointer to a module.
+pub fn module_ref(&self) -> &Module[src]Return a reference to a module.
+pub fn finished_functions(
&self
) -> &BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>[src]Returns the map of all finished JIT functions compiled for this module
+impl !RefUnwindSafe for CompiledModuleimpl !Send for CompiledModuleimpl !Sync for CompiledModuleimpl Unpin for CompiledModuleimpl UnwindSafe for CompiledModuleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A WebAssembly code JIT compiler.
+A Compiler instance owns the executable memory that it allocates.
TODO: Evolve this to support streaming rather than requiring a &[u8]
+containing a whole wasm module at once.
TODO: Consider using cranelift-module.
+impl Compiler[src]pub fn new(
isa: Box<dyn TargetIsa>,
strategy: CompilationStrategy,
cache_config: CacheConfig
) -> Self[src]Construct a new Compiler.
impl Compiler[src]pub fn frontend_config(&self) -> TargetFrontendConfig[src]Return the target's frontend configuration settings.
+pub fn tunables(&self) -> Tunables[src]Return the tunables in use by this engine.
+pub fn get_published_trampoline(
&mut self,
signature: &Signature,
value_size: usize
) -> Result<*const VMFunctionBody, SetupError>[src]Create and publish a trampoline for invoking a function.
+pub fn signatures(&self) -> &SignatureRegistry[src]Shared signature registry.
+pub fn trap_registry(&self) -> &TrapRegistry[src]Shared registration of trap information
+impl !RefUnwindSafe for Compilerimpl !Send for Compilerimpl !Sync for Compilerimpl Unpin for Compilerimpl !UnwindSafe for Compilerimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A handle holding an Instance of a WebAssembly module.
impl InstanceHandle[src]pub unsafe fn new(
module: Arc<Module>,
trap_registration: TrapRegistration,
finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>,
imports: Imports,
data_initializers: &[DataInitializer],
vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
dbg_jit_registration: Option<Rc<GdbJitImageRegistration>>,
host_state: Box<dyn Any + 'static>
) -> Result<InstanceHandle, InstantiationError>[src]Create a new InstanceHandle pointing at a new Instance.
This method is not necessarily inherently unsafe to call, but in general
+the APIs of an Instance are quite unsafe and have not been really
+audited for safety that much. As a result the unsafety here on this
+method is a low-overhead way of saying "this is an extremely unsafe type
+to work with".
Extreme care must be taken when working with InstanceHandle and it's
+recommended to have relatively intimate knowledge of how it works
+internally if you'd like to do so. If possible it's recommended to use
+the wasmtime crate API rather than this type since that is vetted for
+safety.
pub unsafe fn from_vmctx(vmctx: *mut VMContext) -> InstanceHandle[src]Create a new InstanceHandle pointing at the instance
+pointed to by the given VMContext pointer.
This is unsafe because it doesn't work on just any VMContext, it must
+be a VMContext allocated as part of an Instance.
pub fn vmctx(&self) -> &VMContext[src]Return a reference to the vmctx used by compiled wasm code.
+pub fn vmctx_ptr(&self) -> *mut VMContext[src]Return a raw pointer to the vmctx used by compiled wasm code.
+pub fn module(&self) -> &Arc<Module>[src]Return a reference-counting pointer to a module.
+pub fn module_ref(&self) -> &Module[src]Return a reference to a module.
+pub fn lookup(&self, field: &str) -> Option<Export>[src]Lookup an export with the given name.
+pub fn lookup_by_declaration(&self, export: &Export) -> Export[src]Lookup an export with the given export declaration.
+pub fn exports(&self) -> Iter<String, Export>[src]Return an iterator over the exports of this instance.
+Specifically, it provides access to the key-value pairs, where the keys
+are export names, and the values are export declarations which can be
+resolved lookup_by_declaration.
pub fn host_state(&self) -> &(dyn Any + 'static)[src]Return a reference to the custom state attached to this instance.
+pub fn memory_index(&self, memory: &VMMemoryDefinition) -> DefinedMemoryIndex[src]Return the memory index for the given VMMemoryDefinition in this instance.
pub fn memory_grow(
&self,
memory_index: DefinedMemoryIndex,
delta: u32
) -> Option<u32>[src]Grow memory in this instance by the specified amount of pages.
+Returns None if memory can't be grown by the specified amount
+of pages.
pub fn table_index(&self, table: &VMTableDefinition) -> DefinedTableIndex[src]Return the table index for the given VMTableDefinition in this instance.
pub fn table_grow(
&self,
table_index: DefinedTableIndex,
delta: u32
) -> Option<u32>[src]Grow table in this instance by the specified amount of pages.
+Returns None if memory can't be grown by the specified amount
+of pages.
pub fn table_get(
&self,
table_index: DefinedTableIndex,
index: u32
) -> Option<VMCallerCheckedAnyfunc>[src]Get table element reference.
+Returns None if index is out of bounds.
pub fn table_set(
&self,
table_index: DefinedTableIndex,
index: u32,
val: VMCallerCheckedAnyfunc
) -> Result<(), ()>[src]Set table element reference.
+Returns an error if the index is out of bounds
+impl InstanceHandle[src]pub fn set_signal_handler<H>(&mut self, handler: H) where
H: 'static + Fn(i32, *const siginfo_t, *const c_void) -> bool, [src]Set a custom signal handler
+impl Clone for InstanceHandle[src]fn clone(&self) -> InstanceHandle[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Drop for InstanceHandle[src]impl Eq for InstanceHandle[src]impl Hash for InstanceHandle[src]fn hash<__H>(&self, state: &mut __H) where
__H: Hasher, [src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<InstanceHandle> for InstanceHandle[src]fn eq(&self, other: &InstanceHandle) -> bool[src]fn ne(&self, other: &InstanceHandle) -> bool[src]impl StructuralEq for InstanceHandle[src]impl StructuralPartialEq for InstanceHandle[src]impl !RefUnwindSafe for InstanceHandleimpl !Send for InstanceHandleimpl !Sync for InstanceHandleimpl Unpin for InstanceHandleimpl !UnwindSafe for InstanceHandleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Resolver implementation that always resolves to None.
impl Resolver for NullResolver[src]impl RefUnwindSafe for NullResolverimpl Send for NullResolverimpl Sync for NullResolverimpl Unpin for NullResolverimpl UnwindSafe for NullResolverimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime_jit/fn.target_tunables.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_jit/trait.Resolver.html b/api/wasmtime_jit/trait.Resolver.html new file mode 100644 index 000000000000..59468fcd00cd --- /dev/null +++ b/api/wasmtime_jit/trait.Resolver.html @@ -0,0 +1,12 @@ +Import resolver connects imports with available exported values.
+fn resolve(&mut self, index: u32, module: &str, field: &str) -> Option<Export>Resolves an import a WebAssembly module to an export it's hooked up to.
+The index provided is the index of the import in the wasm module
+that's being resolved. For example 1 means that it's the second import
+listed in the wasm module.
The module and field arguments provided are the module/field names
+listed on the import itself.
impl Resolver for NullResolver[src]| NullStackmapSink | Placeholder StackmapSink that does nothing. + |
| NullTrapSink | A |
| TrampolineRelocSink | We don't expect trampoline compilation to produce any relocations, so
+this |
| TrapSink | A trait for receiving trap codes and offsets. + |
| CodeOffset | Offset in bytes from the beginning of the function. + |
Placeholder StackmapSink that does nothing.
+impl StackmapSink for NullStackmapSinkfn add_stackmap(&mut self, u32, Stackmap)impl RefUnwindSafe for NullStackmapSinkimpl Send for NullStackmapSinkimpl Sync for NullStackmapSinkimpl Unpin for NullStackmapSinkimpl UnwindSafe for NullStackmapSinkimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A TrapSink implementation that does nothing, which is convenient when
+compiling code that does not rely on trapping semantics.
impl TrapSink for NullTrapSinkimpl RefUnwindSafe for NullTrapSinkimpl Send for NullTrapSinkimpl Sync for NullTrapSinkimpl Unpin for NullTrapSinkimpl UnwindSafe for NullTrapSinkimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]We don't expect trampoline compilation to produce any relocations, so
+this RelocSink just asserts that it doesn't recieve any.
impl RelocSink for TrampolineRelocSink[src]fn reloc_block(
&mut self,
_offset: CodeOffset,
_reloc: Reloc,
_block_offset: CodeOffset
)[src]fn reloc_external(
&mut self,
_offset: CodeOffset,
_reloc: Reloc,
_name: &ExternalName,
_addend: Addend
)[src]fn reloc_constant(
&mut self,
_code_offset: CodeOffset,
_reloc: Reloc,
_constant_offset: ConstantOffset
)[src]fn reloc_jt(&mut self, _offset: CodeOffset, _reloc: Reloc, _jt: JumpTable)[src]impl RefUnwindSafe for TrampolineRelocSinkimpl Send for TrampolineRelocSinkimpl Sync for TrampolineRelocSinkimpl Unpin for TrampolineRelocSinkimpl UnwindSafe for TrampolineRelocSinkimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A trait for receiving trap codes and offsets.
+If you don't need information about possible traps, you can use the
+NullTrapSink implementation.
impl TrapSink for NullTrapSinktype CodeOffset = u32;
Offset in bytes from the beginning of the function.
+Cranelift can be used as a cross compiler, so we don't want to use a type like usize which
+depends on the host platform, not the target platform.
pub fn pretty_error(
func: &Function,
isa: Option<&dyn TargetIsa>,
err: CodegenError
) -> String
Pretty-print a Cranelift error.
+| binemit | |
| ir |
| Context | Persistent data structures and compilation pipeline. + |
| FunctionBuilder | Temporary object used to build a single Cranelift IR |
| FunctionBuilderContext | Structure used for translating a series of functions into Cranelift IR. + |
| pretty_error | Pretty-print a Cranelift error. + |
The name of an external is either a reference to a user-defined symbol +table, or a short sequence of ascii bytes so that test cases do not have +to keep track of a symbol table.
+External names are primarily used as keys by code using Cranelift to map
+from a cranelift_codegen::ir::FuncRef or similar to additional associated
+data.
External names can also serve as a primitive testing and debugging tool.
+In particular, many .clif test files use function names to identify
+functions.
A name in a user-defined symbol table. Cranelift does not interpret +these numbers in any way.
+A test case function name of up to a hardcoded amount of ascii +characters. This is not intended to be used outside test cases.
+A well-known runtime library function.
+impl ExternalNamepub fn testcase<T>(v: T) -> ExternalName where
T: AsRef<[u8]>, Creates a new external name from a sequence of bytes. Caller is expected
+to guarantee bytes are only ascii alphanumeric or _.
+// Create `ExternalName` from a string. +let name = ExternalName::testcase("hello"); +assert_eq!(name.to_string(), "%hello");
pub fn user(namespace: u32, index: u32) -> ExternalNameCreate a new external name from user-provided integer indices.
++// Create `ExternalName` from integer indices +let name = ExternalName::user(123, 456); +assert_eq!(name.to_string(), "u123:456");
impl Clone for ExternalNamefn clone(&self) -> ExternalNamefn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for ExternalNameimpl Default for ExternalNamefn default() -> ExternalNameimpl Display for ExternalNameimpl Eq for ExternalNameimpl FromStr for ExternalNametype Err = ()The associated error which can be returned from parsing.
+fn from_str(s: &str) -> Result<ExternalName, <ExternalName as FromStr>::Err>impl PartialEq<ExternalName> for ExternalNamefn eq(&self, other: &ExternalName) -> boolfn ne(&self, other: &ExternalName) -> boolimpl StructuralEq for ExternalNameimpl StructuralPartialEq for ExternalNameimpl RefUnwindSafe for ExternalNameimpl Send for ExternalNameimpl Sync for ExternalNameimpl Unpin for ExternalNameimpl UnwindSafe for ExternalNameimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The kind of a stack slot.
+A spill slot. This is a stack slot created by the register allocator.
+An explicit stack slot. This is a chunk of stack memory for use by the stack_load
+and stack_store instructions.
An incoming function argument.
+If the current function has more arguments than fits in registers, the remaining arguments +are passed on the stack by the caller. These incoming arguments are represented as SSA +values assigned to incoming stack slots.
+An outgoing function argument.
+When preparing to call a function whose arguments don't fit in registers, outgoing argument +stack slots are used to represent individual arguments in the outgoing call frame. These +stack slots are only valid while setting up a call.
+Space allocated in the caller's frame for the callee's return values +that are passed out via return pointer.
+If there are more return values than registers available for the callee's calling +convention, or the return value is larger than the available registers' space, then we +allocate stack space in this frame and pass a pointer to the callee, which then writes its +return values into this space.
+An emergency spill slot.
+Emergency slots are allocated late when the register's constraint solver needs extra space +to shuffle registers around. They are only used briefly, and can be reused.
+impl Clone for StackSlotKindfn clone(&self) -> StackSlotKindfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for StackSlotKindimpl Debug for StackSlotKindimpl<'de> Deserialize<'de> for StackSlotKindfn deserialize<__D>(
__deserializer: __D
) -> Result<StackSlotKind, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Display for StackSlotKindimpl Eq for StackSlotKindimpl FromStr for StackSlotKindtype Err = ()The associated error which can be returned from parsing.
+fn from_str(s: &str) -> Result<StackSlotKind, ()>impl PartialEq<StackSlotKind> for StackSlotKindimpl Serialize for StackSlotKindfn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for StackSlotKindimpl StructuralPartialEq for StackSlotKindimpl RefUnwindSafe for StackSlotKindimpl Send for StackSlotKindimpl Sync for StackSlotKindimpl Unpin for StackSlotKindimpl UnwindSafe for StackSlotKindimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]| Function | A function. + |
| MemFlags | Flags for memory operations like load/store. + |
| StackSlotData | Contents of a stack slot. + |
| ExternalName | The name of an external is either a reference to a user-defined symbol +table, or a short sequence of ascii bytes so that test cases do not have +to keep track of a symbol table. + |
| StackSlotKind | The kind of a stack slot. + |
| InstBuilder | Convenience methods for building instructions. + |
A function.
+Functions can be cloned, but it is not a very fast operation. +The clone will have all the same entity numbers as the original.
+name: ExternalNameName of this function. Mostly used by .clif files.
signature: SignatureSignature of this function.
+old_signature: Option<Signature>The old signature of this function, before the most recent legalization, +if any.
+stack_slots: StackSlotsStack slots allocated in this function.
+global_values: PrimaryMap<GlobalValue, GlobalValueData>Global values referenced.
+heaps: PrimaryMap<Heap, HeapData>Heaps referenced.
+tables: PrimaryMap<Table, TableData>Tables referenced.
+jump_tables: PrimaryMap<JumpTable, JumpTableData>Jump tables used in this function.
+dfg: DataFlowGraphData flow graph containing the primary definition of all instructions, blocks and values.
+layout: LayoutLayout of blocks and instructions in the function body.
+encodings: SecondaryMap<Inst, Encoding>Encoding recipe and bits for the legal instructions.
+Illegal instructions have the Encoding::default() value.
locations: SecondaryMap<Value, ValueLoc>Location assigned to every value.
+entry_diversions: EntryRegDiversionsNon-default locations assigned to value at the entry of basic blocks.
+At the entry of each basic block, we might have values which are not in their default +ValueLocation. This field records these register-to-register moves as Diversions.
+offsets: SecondaryMap<Block, u32>Code offsets of the block headers.
+This information is only transiently available after the binemit::relax_branches function
+computes it, and it can easily be recomputed by calling that function. It is not included
+in the textual IR format.
jt_offsets: SecondaryMap<JumpTable, u32>Code offsets of Jump Table headers.
+srclocs: SecondaryMap<Inst, SourceLoc>Source locations.
+Track the original source location for each instruction. The source locations are not +interpreted by Cranelift, only preserved.
+prologue_end: Option<Inst>Instruction that marks the end (inclusive) of the function's prologue.
+This is used for some calling conventions to track the end of unwind information.
+frame_layout: Option<FrameLayout>Frame layout for the instructions.
+The stack unwinding requires to have information about which registers and where they +are saved in the frame. This information is created during the prologue and epilogue +passes.
+impl Functionpub fn with_name_signature(name: ExternalName, sig: Signature) -> FunctionCreate a function with the given name and signature.
+pub fn clear(&mut self)Clear all data structures in this function.
+pub fn new() -> FunctionCreate a new empty, anonymous function with a Fast calling convention.
+pub fn create_jump_table(&mut self, data: JumpTableData) -> JumpTableCreates a jump table in the function, to be used by br_table instructions.
pub fn create_stack_slot(&mut self, data: StackSlotData) -> StackSlotCreates a stack slot in the function, to be used by stack_load, stack_store and
+stack_addr instructions.
pub fn import_signature(&mut self, signature: Signature) -> SigRefAdds a signature which can later be used to declare an external function import.
+pub fn import_function(&mut self, data: ExtFuncData) -> FuncRefDeclare an external function import.
+pub fn create_global_value(&mut self, data: GlobalValueData) -> GlobalValueDeclares a global value accessible to the function.
+pub fn create_heap(&mut self, data: HeapData) -> HeapDeclares a heap accessible to the function.
+pub fn create_table(&mut self, data: TableData) -> TableDeclares a table accessible to the function.
+pub fn display<'a, I>(&'a self, isa: I) -> DisplayFunction<'a> where
I: Into<Option<&'a (dyn TargetIsa + 'a)>>, Return an object that can display this function with correct ISA-specific annotations.
+pub fn display_with(
&'a self,
annotations: DisplayFunctionAnnotations<'a>
) -> DisplayFunction<'a>Return an object that can display this function with correct ISA-specific annotations.
+pub fn special_param(&self, purpose: ArgumentPurpose) -> Option<Value>Find a presumed unique special-purpose function parameter value.
+Returns the value of the last purpose parameter, or None if no such parameter exists.
pub fn inst_offsets(
&'a self,
block: Block,
encinfo: &EncInfo
) -> InstOffsetIter<'a>Get an iterator over the instructions in block, including offsets and encoded instruction
+sizes.
The iterator returns (offset, inst, size) tuples, where offset if the offset in bytes
+from the beginning of the function to the instruction, and size is the size of the
+instruction in bytes, or 0 for unencoded instructions.
This function can only be used after the code layout has been computed by the
+binemit::relax_branches() function.
pub fn update_encoding(
&mut self,
inst: Inst,
isa: &dyn TargetIsa
) -> Result<(), fn(Inst, &mut Function, &mut ControlFlowGraph, &dyn TargetIsa) -> bool>Wrapper around encode which assigns inst the resulting encoding.
pub fn encode(
&self,
inst: Inst,
isa: &dyn TargetIsa
) -> Result<Encoding, fn(Inst, &mut Function, &mut ControlFlowGraph, &dyn TargetIsa) -> bool>Wrapper around TargetIsa::encode for encoding an existing instruction
+in the Function.
pub fn collect_debug_info(&mut self)Starts collection of debug information.
+pub fn collect_frame_layout_info(&mut self)Starts collection of frame layout information.
+pub fn change_branch_destination(&mut self, inst: Inst, new_dest: Block)Changes the destination of a jump or branch instruction. +Does nothing if called with a non-jump or non-branch instruction.
+pub fn is_block_basic(&self, block: Block) -> Result<(), (Inst, &'static str)>Checks that the specified block can be encoded as a basic block.
+On error, returns the first invalid instruction and an error message.
+pub fn is_leaf(&self) -> boolReturns true if the function is function that doesn't call any other functions. This is not +to be confused with a "leaf function" in Windows terminology.
+impl Clone for Functionfn clone(&self) -> Functionfn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for Functionimpl Display for Functionimpl RefUnwindSafe for Functionimpl Send for Functionimpl Sync for Functionimpl Unpin for Functionimpl UnwindSafe for Functionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Flags for memory operations like load/store.
+Each of these flags introduce a limited form of undefined behavior. The flags each enable +certain optimizations that need to make additional assumptions. Generally, the semantics of a +program does not change when a flag is removed, but adding a flag will.
+impl MemFlagspub fn new() -> MemFlagsCreate a new empty set of flags.
+pub fn trusted() -> MemFlagsCreate a set of flags representing an access from a "trusted" address, meaning it's +known to be aligned and non-trapping.
+pub fn set_by_name(&mut self, name: &str) -> boolSet a flag bit by name.
+Returns true if the flag was found and set, false for an unknown flag name.
+pub fn notrap(self) -> boolTest if the notrap flag is set.
Normally, trapping is part of the semantics of a load/store operation. If the platform +would cause a trap when accessing the effective address, the Cranelift memory operation is +also required to trap.
+The notrap flag tells Cranelift that the memory is accessible, which means that
+accesses will not trap. This makes it possible to delete an unused load or a dead store
+instruction.
pub fn set_notrap(&mut self)Set the notrap flag.
pub fn aligned(self) -> boolTest if the aligned flag is set.
By default, Cranelift memory instructions work with any unaligned effective address. If the
+aligned flag is set, the instruction is permitted to trap or return a wrong result if the
+effective address is misaligned.
pub fn set_aligned(&mut self)Set the aligned flag.
pub fn readonly(self) -> boolTest if the readonly flag is set.
Loads with this flag have no memory dependencies. +This results in undefined behavior if the dereferenced memory is mutated at any time +between when the function is called and when it is exited.
+pub fn set_readonly(&mut self)Set the readonly flag.
impl Clone for MemFlagsfn clone(&self) -> MemFlagsfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for MemFlagsimpl Debug for MemFlagsimpl Display for MemFlagsimpl Eq for MemFlagsimpl Hash for MemFlagsfn hash<__H>(&self, state: &mut __H) where
__H: Hasher, fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<MemFlags> for MemFlagsimpl StructuralEq for MemFlagsimpl StructuralPartialEq for MemFlagsimpl RefUnwindSafe for MemFlagsimpl Send for MemFlagsimpl Sync for MemFlagsimpl Unpin for MemFlagsimpl UnwindSafe for MemFlagsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Contents of a stack slot.
+kind: StackSlotKindThe kind of stack slot.
+size: u32Size of stack slot in bytes.
+offset: Option<i32>Offset of stack slot relative to the stack pointer in the caller.
+On x86, the base address is the stack pointer before the return address was pushed. On +RISC ISAs, the base address is the value of the stack pointer on entry to the function.
+For OutgoingArg stack slots, the offset is relative to the current function's stack
+pointer immediately before the call.
impl StackSlotDatapub fn new(kind: StackSlotKind, size: u32) -> StackSlotDataCreate a stack slot with the specified byte size.
+pub fn alignment(&self, max_align: u32) -> u32Get the alignment in bytes of this stack slot given the stack pointer alignment.
+impl Clone for StackSlotDatafn clone(&self) -> StackSlotDatafn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for StackSlotDataimpl<'de> Deserialize<'de> for StackSlotDatafn deserialize<__D>(
__deserializer: __D
) -> Result<StackSlotData, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>, impl Display for StackSlotDataimpl Eq for StackSlotDataimpl PartialEq<StackSlotData> for StackSlotDatafn eq(&self, other: &StackSlotData) -> boolfn ne(&self, other: &StackSlotData) -> boolimpl Serialize for StackSlotDatafn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer, impl StructuralEq for StackSlotDataimpl StructuralPartialEq for StackSlotDataimpl RefUnwindSafe for StackSlotDataimpl Send for StackSlotDataimpl Sync for StackSlotDataimpl Unpin for StackSlotDataimpl UnwindSafe for StackSlotDataimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> DeserializeOwned for T where
T: Deserialize<'de>, [src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Convenience methods for building instructions.
+The InstBuilder trait has one method per instruction opcode for
+conveniently constructing the instruction with minimum arguments.
+Polymorphic instructions infer their result types from the input
+arguments when possible. In some cases, an explicit ctrl_typevar
+argument is required.
The opcode methods return the new instruction's result values, or
+the Inst itself for instructions that don't have any results.
There is also a method per instruction format. These methods all
+return an Inst.
fn jump(self, block: Block, args: &[Value]) -> InstJump.
+Unconditionally jump to a basic block, passing the specified +block arguments. The number and types of arguments must match the +destination block.
+Inputs:
+fn fallthrough(self, block: Block, args: &[Value]) -> InstFall through to the next block.
+This is the same as jump, except the destination block must be
+the next one in the layout.
Jumps are turned into fall-through instructions by the branch +relaxation pass. There is no reason to use this instruction outside +that pass.
+Inputs:
+fn brz(self, c: Value, block: Block, args: &[Value]) -> InstBranch when zero.
+If c is a b1 value, take the branch when c is false. If
+c is an integer value, take the branch when c = 0.
Inputs:
+fn brnz(self, c: Value, block: Block, args: &[Value]) -> InstBranch when non-zero.
+If c is a b1 value, take the branch when c is true. If
+c is an integer value, take the branch when c != 0.
Inputs:
+fn br_icmp<T1>(
self,
Cond: T1,
x: Value,
y: Value,
block: Block,
args: &[Value]
) -> Inst where
T1: Into<IntCC>, Compare scalar integers and branch.
+Compare x and y in the same way as the icmp instruction
+and take the branch if the condition is true:
br_icmp ugt v1, v2, block4(v5, v6)
+is semantically equivalent to:
+ v10 = icmp ugt, v1, v2
+ brnz v10, block4(v5, v6)
+Some RISC architectures like MIPS and RISC-V provide instructions that +implement all or some of the condition codes. The instruction can also +be used to represent macro-op fusion on architectures like Intel's.
+Inputs:
+fn brif<T1>(self, Cond: T1, f: Value, block: Block, args: &[Value]) -> Inst where
T1: Into<IntCC>, Branch when condition is true in integer CPU flags.
+Inputs:
+intcc condition code.fn brff<T1>(self, Cond: T1, f: Value, block: Block, args: &[Value]) -> Inst where
T1: Into<FloatCC>, Branch when condition is true in floating point CPU flags.
+Inputs:
+floatcc condition code.fn br_table(self, x: Value, block: Block, JT: JumpTable) -> InstIndirect branch via jump table.
+Use x as an unsigned index into the jump table JT. If a jump
+table entry is found, branch to the corresponding block. If no entry was
+found or the index is out-of-bounds, branch to the given default block.
Note that this branch instruction can't pass arguments to the targeted +blocks. Split critical edges as needed to work around this.
+Do not confuse this with "tables" in WebAssembly. br_table is for
+jump tables with destinations within the current function only -- think
+of a match in Rust or a switch in C. If you want to call a
+function in a dynamic library, that will typically use
+call_indirect.
Inputs:
+fn jump_table_entry<T1>(
self,
x: Value,
addr: Value,
Size: T1,
JT: JumpTable
) -> Value where
T1: Into<u8>, Get an entry from a jump table.
+Load a serialized entry from a jump table JT at a given index
+addr with a specific Size. The retrieved entry may need to be
+decoded after loading, depending upon the jump table type used.
Currently, the only type supported is entries which are relative to the +base of the jump table.
+Inputs:
+Outputs:
+fn jump_table_base(self, iAddr: Type, JT: JumpTable) -> ValueGet the absolute base address of a jump table.
+This is used for jump tables wherein the entries are stored relative to
+the base of jump table. In order to use these, generated code should first
+load an entry using jump_table_entry, then use this instruction to add
+the relative base back to it.
Inputs:
+Outputs:
+fn indirect_jump_table_br(self, addr: Value, JT: JumpTable) -> InstBranch indirectly via a jump table entry.
+Unconditionally jump via a jump table entry that was previously loaded
+with the jump_table_entry instruction.
Inputs:
+fn debugtrap(self) -> InstEncodes an assembly debug trap.
+fn trap<T1>(self, code: T1) -> Inst where
T1: Into<TrapCode>, Terminate execution unconditionally.
+Inputs:
+fn trapz<T1>(self, c: Value, code: T1) -> Inst where
T1: Into<TrapCode>, Trap when zero.
+if c is non-zero, execution continues at the following instruction.
Inputs:
+fn resumable_trap<T1>(self, code: T1) -> Inst where
T1: Into<TrapCode>, A resumable trap.
+This instruction allows non-conditional traps to be used as non-terminal instructions.
+Inputs:
+fn trapnz<T1>(self, c: Value, code: T1) -> Inst where
T1: Into<TrapCode>, Trap when non-zero.
+if c is zero, execution continues at the following instruction.
Inputs:
+fn trapif<T1, T2>(self, Cond: T1, f: Value, code: T2) -> Inst where
T1: Into<IntCC>,
T2: Into<TrapCode>, Trap when condition is true in integer CPU flags.
+Inputs:
+intcc condition code.fn trapff<T1, T2>(self, Cond: T1, f: Value, code: T2) -> Inst where
T1: Into<FloatCC>,
T2: Into<TrapCode>, Trap when condition is true in floating point CPU flags.
+Inputs:
+floatcc condition code.fn return_(self, rvals: &[Value]) -> InstReturn from the function.
+Unconditionally transfer control to the calling function, passing the +provided return values. The list of return values must match the +function signature's return types.
+Inputs:
+fn fallthrough_return(self, rvals: &[Value]) -> InstReturn from the function by fallthrough.
+This is a specialized instruction for use where one wants to append +a custom epilogue, which will then perform the real return. This +instruction has no encoding.
+Inputs:
+fn call(self, FN: FuncRef, args: &[Value]) -> InstDirect function call.
+Call a function which has been declared in the preamble. The argument +types must match the function's signature.
+Inputs:
+functionOutputs:
+fn call_indirect(self, SIG: SigRef, callee: Value, args: &[Value]) -> InstIndirect function call.
+Call the function pointed to by callee with the given arguments. The
+called function must match the specified signature.
Note that this is different from WebAssembly's call_indirect; the
+callee is a native address, rather than a table index. For WebAssembly,
+table_addr and load are used to obtain a native address
+from a table.
Inputs:
+Outputs:
+fn func_addr(self, iAddr: Type, FN: FuncRef) -> ValueGet the address of a function.
+Compute the absolute address of a function declared in the preamble.
+The returned address can be used as a callee argument to
+call_indirect. This is also a method for calling functions that
+are too far away to be addressable by a direct call
+instruction.
Inputs:
+functionOutputs:
+fn load<T1, T2>(self, Mem: Type, MemFlags: T1, p: Value, Offset: T2) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load from memory at p + Offset.
This is a polymorphic instruction that can load any value type which +has a memory representation.
+Inputs:
+Outputs:
+fn load_complex<T1, T2>(
self,
Mem: Type,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load from memory at sum(args) + Offset.
This is a polymorphic instruction that can load any value type which +has a memory representation.
+Inputs:
+Outputs:
+fn store<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store x to memory at p + Offset.
This is a polymorphic instruction that can store any value type with a +memory representation.
+Inputs:
+fn store_complex<T1, T2>(
self,
MemFlags: T1,
x: Value,
args: &[Value],
Offset: T2
) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store x to memory at sum(args) + Offset.
This is a polymorphic instruction that can store any value type with a +memory representation.
+Inputs:
+fn uload8<T1, T2>(
self,
iExt8: Type,
MemFlags: T1,
p: Value,
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 8 bits from memory at p + Offset and zero-extend.
This is equivalent to load.i8 followed by uextend.
Inputs:
+Outputs:
+fn uload8_complex<T1, T2>(
self,
iExt8: Type,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 8 bits from memory at sum(args) + Offset and zero-extend.
This is equivalent to load.i8 followed by uextend.
Inputs:
+Outputs:
+fn sload8<T1, T2>(
self,
iExt8: Type,
MemFlags: T1,
p: Value,
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 8 bits from memory at p + Offset and sign-extend.
This is equivalent to load.i8 followed by sextend.
Inputs:
+Outputs:
+fn sload8_complex<T1, T2>(
self,
iExt8: Type,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 8 bits from memory at sum(args) + Offset and sign-extend.
This is equivalent to load.i8 followed by sextend.
Inputs:
+Outputs:
+fn istore8<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 8 bits of x to memory at p + Offset.
This is equivalent to ireduce.i8 followed by store.i8.
Inputs:
+fn istore8_complex<T1, T2>(
self,
MemFlags: T1,
x: Value,
args: &[Value],
Offset: T2
) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 8 bits of x to memory at sum(args) + Offset.
This is equivalent to ireduce.i8 followed by store.i8.
Inputs:
+fn uload16<T1, T2>(
self,
iExt16: Type,
MemFlags: T1,
p: Value,
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 16 bits from memory at p + Offset and zero-extend.
This is equivalent to load.i16 followed by uextend.
Inputs:
+Outputs:
+fn uload16_complex<T1, T2>(
self,
iExt16: Type,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 16 bits from memory at sum(args) + Offset and zero-extend.
This is equivalent to load.i16 followed by uextend.
Inputs:
+Outputs:
+fn sload16<T1, T2>(
self,
iExt16: Type,
MemFlags: T1,
p: Value,
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 16 bits from memory at p + Offset and sign-extend.
This is equivalent to load.i16 followed by sextend.
Inputs:
+Outputs:
+fn sload16_complex<T1, T2>(
self,
iExt16: Type,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 16 bits from memory at sum(args) + Offset and sign-extend.
This is equivalent to load.i16 followed by sextend.
Inputs:
+Outputs:
+fn istore16<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 16 bits of x to memory at p + Offset.
This is equivalent to ireduce.i16 followed by store.i16.
Inputs:
+fn istore16_complex<T1, T2>(
self,
MemFlags: T1,
x: Value,
args: &[Value],
Offset: T2
) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 16 bits of x to memory at sum(args) + Offset.
This is equivalent to ireduce.i16 followed by store.i16.
Inputs:
+fn uload32<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 32 bits from memory at p + Offset and zero-extend.
This is equivalent to load.i32 followed by uextend.
Inputs:
+Outputs:
+fn uload32_complex<T1, T2>(
self,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 32 bits from memory at sum(args) + Offset and zero-extend.
This is equivalent to load.i32 followed by uextend.
Inputs:
+Outputs:
+fn sload32<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 32 bits from memory at p + Offset and sign-extend.
This is equivalent to load.i32 followed by sextend.
Inputs:
+Outputs:
+fn sload32_complex<T1, T2>(
self,
MemFlags: T1,
args: &[Value],
Offset: T2
) -> Value where
T1: Into<MemFlags>,
T2: Into<Offset32>, Load 32 bits from memory at sum(args) + Offset and sign-extend.
This is equivalent to load.i32 followed by sextend.
Inputs:
+Outputs:
+fn istore32<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 32 bits of x to memory at p + Offset.
This is equivalent to ireduce.i32 followed by store.i32.
Inputs:
+fn istore32_complex<T1, T2>(
self,
MemFlags: T1,
x: Value,
args: &[Value],
Offset: T2
) -> Inst where
T1: Into<MemFlags>,
T2: Into<Offset32>, Store the low 32 bits of x to memory at sum(args) + Offset.
This is equivalent to ireduce.i32 followed by store.i32.
Inputs:
+fn stack_load<T1>(self, Mem: Type, SS: StackSlot, Offset: T1) -> Value where
T1: Into<Offset32>, Load a value from a stack slot at the constant offset.
+This is a polymorphic instruction that can load any value type which +has a memory representation.
+The offset is an immediate constant, not an SSA value. The memory
+access cannot go out of bounds, i.e.
+sizeof(a) + Offset <= sizeof(SS).
Inputs:
+Outputs:
+fn stack_store<T1>(self, x: Value, SS: StackSlot, Offset: T1) -> Inst where
T1: Into<Offset32>, Store a value to a stack slot at a constant offset.
+This is a polymorphic instruction that can store any value type with a +memory representation.
+The offset is an immediate constant, not an SSA value. The memory
+access cannot go out of bounds, i.e.
+sizeof(a) + Offset <= sizeof(SS).
Inputs:
+fn stack_addr<T1>(self, iAddr: Type, SS: StackSlot, Offset: T1) -> Value where
T1: Into<Offset32>, Get the address of a stack slot.
+Compute the absolute address of a byte in a stack slot. The offset must
+refer to a byte inside the stack slot:
+0 <= Offset < sizeof(SS).
Inputs:
+Outputs:
+fn global_value(self, Mem: Type, GV: GlobalValue) -> ValueCompute the value of global GV.
+Inputs:
+Outputs:
+fn symbol_value(self, Mem: Type, GV: GlobalValue) -> ValueCompute the value of global GV, which is a symbolic value.
+Inputs:
+Outputs:
+fn heap_addr<T1>(self, iAddr: Type, H: Heap, p: Value, Size: T1) -> Value where
T1: Into<Uimm32>, Bounds check and compute absolute address of heap memory.
+Verify that the offset range p .. p + Size - 1 is in bounds for the
+heap H, and generate an absolute address that is safe to dereference.
p + Size is not greater than the heap bound, return an
+absolute address corresponding to a byte offset of p from the
+heap's base address.p + Size is greater than the heap bound, generate a trap.Inputs:
+Outputs:
+fn get_pinned_reg(self, iAddr: Type) -> ValueGets the content of the pinned register, when it's enabled.
+Inputs:
+Outputs:
+fn set_pinned_reg(self, addr: Value) -> InstSets the content of the pinned register, when it's enabled.
+Inputs:
+fn table_addr<T1>(self, iAddr: Type, T: Table, p: Value, Offset: T1) -> Value where
T1: Into<Offset32>, Bounds check and compute absolute address of a table entry.
+Verify that the offset p is in bounds for the table T, and generate
+an absolute address that is safe to dereference.
Offset must be less than the size of a table element.
p is not greater than the table bound, return an absolute
+address corresponding to a byte offset of p from the table's
+base address.p is greater than the table bound, generate a trap.Inputs:
+Outputs:
+fn iconst<T1>(self, Int: Type, N: T1) -> Value where
T1: Into<Imm64>, Integer constant.
+Create a scalar integer SSA value with an immediate constant value, or +an integer vector where all the lanes have the same value.
+Inputs:
+Outputs:
+fn f32const<T1>(self, N: T1) -> Value where
T1: Into<Ieee32>, Floating point constant.
+Create a f32 SSA value with an immediate constant value.
Inputs:
+Outputs:
+fn f64const<T1>(self, N: T1) -> Value where
T1: Into<Ieee64>, Floating point constant.
+Create a f64 SSA value with an immediate constant value.
Inputs:
+Outputs:
+fn bconst<T1>(self, Bool: Type, N: T1) -> Value where
T1: Into<bool>, Boolean constant.
+Create a scalar boolean SSA value with an immediate constant value, or +a boolean vector where all the lanes have the same value.
+Inputs:
+Outputs:
+fn vconst<T1>(self, TxN: Type, N: T1) -> Value where
T1: Into<Constant>, SIMD vector constant.
+Construct a vector with the given immediate bytes.
+Inputs:
+Outputs:
+fn shuffle<T1>(self, a: Value, b: Value, mask: T1) -> Value where
T1: Into<Immediate>, SIMD vector shuffle.
+Shuffle two vectors using the given immediate bytes. For each of the 16 bytes of the +immediate, a value i of 0-15 selects the i-th element of the first vector and a value i of +16-31 selects the (i-16)th element of the second vector. Immediate values outside of the +0-31 range place a 0 in the resulting vector lane.
+Inputs:
+Outputs:
+fn null(self, Ref: Type) -> ValueNull constant value for reference types.
+Create a scalar reference SSA value with a constant null value.
+Inputs:
+Outputs:
+fn nop(self) -> InstJust a dummy instruction.
+Note: this doesn't compile to a machine code nop.
+fn select(self, c: Value, x: Value, y: Value) -> ValueConditional select.
+This instruction selects whole values. Use vselect for
+lane-wise selection.
Inputs:
+c is truec is falseOutputs:
+fn selectif<T1>(
self,
Any: Type,
cc: T1,
flags: Value,
x: Value,
y: Value
) -> Value where
T1: Into<IntCC>, Conditional select, dependent on integer condition codes.
+Inputs:
+c is truec is falseOutputs:
+fn bitselect(self, c: Value, x: Value, y: Value) -> ValueConditional select of bits.
+For each bit in c, this instruction selects the corresponding bit from x if the bit
+in c is 1 and the corresponding bit from y if the bit in c is 0. See also:
+select, vselect.
Inputs:
+c is truec is falseOutputs:
+fn copy(self, x: Value) -> ValueRegister-register copy.
+This instruction copies its input, preserving the value type.
+A pure SSA-form program does not need to copy values, but this +instruction is useful for representing intermediate stages during +instruction transformations, and the register allocator needs a way of +representing register copies.
+Inputs:
+Outputs:
+fn spill(self, x: Value) -> ValueSpill a register value to a stack slot.
+This instruction behaves exactly like copy, but the result
+value is assigned to a spill slot.
Inputs:
+Outputs:
+fn fill(self, x: Value) -> ValueLoad a register value from a stack slot.
+This instruction behaves exactly like copy, but creates a new
+SSA value for the spilled input value.
Inputs:
+Outputs:
+fn fill_nop(self, x: Value) -> ValueThis is identical to fill, except it has no encoding, since it is a no-op.
This instruction is created only during late-stage redundant-reload removal, after all
+registers and stack slots have been assigned. It is used to replace fills that have
+been identified as redundant.
Inputs:
+Outputs:
+fn regmove<T1, T2>(self, x: Value, src: T1, dst: T2) -> Inst where
T1: Into<u16>,
T2: Into<u16>, Temporarily divert x from src to dst.
This instruction moves the location of a value from one register to +another without creating a new SSA value. It is used by the register +allocator to temporarily rearrange register assignments in order to +satisfy instruction constraints.
+The register diversions created by this instruction must be undone +before the value leaves the block. At the entry to a new block, all live +values must be in their originally assigned registers.
+Inputs:
+fn copy_special<T1, T2>(self, src: T1, dst: T2) -> Inst where
T1: Into<u16>,
T2: Into<u16>, Copies the contents of ''src'' register to ''dst'' register.
+This instructions copies the contents of one register to another +register without involving any SSA values. This is used for copying +special registers, e.g. copying the stack register to the frame +register in a function prologue.
+Inputs:
+fn copy_to_ssa<T1>(self, Any: Type, src: T1) -> Value where
T1: Into<u16>, Copies the contents of ''src'' register to ''a'' SSA name.
+This instruction copies the contents of one register, regardless of its SSA name, to +another register, creating a new SSA name. In that sense it is a one-sided version +of ''copy_special''. This instruction is internal and should not be created by +Cranelift users.
+Inputs:
+Outputs:
+fn copy_nop(self, x: Value) -> ValueStack-slot-to-the-same-stack-slot copy, which is guaranteed to turn +into a no-op. This instruction is for use only within Cranelift itself.
+This instruction copies its input, preserving the value type.
+Inputs:
+Outputs:
+fn adjust_sp_down(self, delta: Value) -> InstSubtracts delta offset value from the stack pointer register.
This instruction is used to adjust the stack pointer by a dynamic amount.
+Inputs:
+fn adjust_sp_up_imm<T1>(self, Offset: T1) -> Inst where
T1: Into<Imm64>, Adds Offset immediate offset value to the stack pointer register.
This instruction is used to adjust the stack pointer, primarily in function
+prologues and epilogues. Offset is constrained to the size of a signed
+32-bit integer.
Inputs:
+fn adjust_sp_down_imm<T1>(self, Offset: T1) -> Inst where
T1: Into<Imm64>, Subtracts Offset immediate offset value from the stack pointer
+register.
This instruction is used to adjust the stack pointer, primarily in function
+prologues and epilogues. Offset is constrained to the size of a signed
+32-bit integer.
Inputs:
+fn ifcmp_sp(self, addr: Value) -> ValueCompare addr with the stack pointer and set the CPU flags.
This is like ifcmp where addr is the LHS operand and the stack
+pointer is the RHS.
Inputs:
+Outputs:
+intcc condition code.fn regspill<T1>(self, x: Value, src: T1, SS: StackSlot) -> Inst where
T1: Into<u16>, Temporarily divert x from src to SS.
This instruction moves the location of a value from a register to a +stack slot without creating a new SSA value. It is used by the register +allocator to temporarily rearrange register assignments in order to +satisfy instruction constraints.
+See also regmove.
Inputs:
+fn regfill<T1>(self, x: Value, SS: StackSlot, dst: T1) -> Inst where
T1: Into<u16>, Temporarily divert x from SS to dst.
This instruction moves the location of a value from a stack slot to a +register without creating a new SSA value. It is used by the register +allocator to temporarily rearrange register assignments in order to +satisfy instruction constraints.
+See also regmove.
Inputs:
+fn safepoint(self, args: &[Value]) -> InstThis instruction will provide live reference values at a point in +the function. It can only be used by the compiler.
+Inputs:
+fn vsplit(self, x: Value) -> (Value, Value)Split a vector into two halves.
+Split the vector x into two separate values, each containing half of
+the lanes from x. The result may be two scalars if x only had
+two lanes.
Inputs:
+Outputs:
+xxfn vconcat(self, x: Value, y: Value) -> ValueVector concatenation.
+Return a vector formed by concatenating x and y. The resulting
+vector type has twice as many lanes as each of the inputs. The lanes of
+x appear as the low-numbered lanes, and the lanes of y become
+the high-numbered lanes of a.
It is possible to form a vector by concatenating two scalars.
+Inputs:
+Outputs:
+x and yfn vselect(self, c: Value, x: Value, y: Value) -> ValueVector lane select.
+Select lanes from x or y controlled by the lanes of the boolean
+vector c.
Inputs:
+c is truec is falseOutputs:
+fn vany_true(self, a: Value) -> ValueReduce a vector to a scalar boolean.
+Return a scalar boolean true if any lane in a is non-zero, false otherwise.
Inputs:
+Outputs:
+fn vall_true(self, a: Value) -> ValueReduce a vector to a scalar boolean.
+Return a scalar boolean true if all lanes in i are non-zero, false otherwise.
Inputs:
+Outputs:
+fn splat(self, TxN: Type, x: Value) -> ValueVector splat.
+Return a vector whose lanes are all x.
Inputs:
+Outputs:
+fn insertlane<T1>(self, x: Value, Idx: T1, y: Value) -> Value where
T1: Into<u8>, Insert y as lane Idx in x.
The lane index, Idx, is an immediate value, not an SSA value. It
+must indicate a valid lane index for the type of x.
Inputs:
+Outputs:
+fn extractlane<T1>(self, x: Value, Idx: T1) -> Value where
T1: Into<u8>, Extract lane Idx from x.
The lane index, Idx, is an immediate value, not an SSA value. It
+must indicate a valid lane index for the type of x. Note that the upper bits of a
+may or may not be zeroed depending on the ISA but the type system should prevent using
+a as anything other than the extracted value.
Inputs:
+Outputs:
+fn icmp<T1>(self, Cond: T1, x: Value, y: Value) -> Value where
T1: Into<IntCC>, Integer comparison.
+The condition code determines if the operands are interpreted as signed +or unsigned integers.
+| Signed | Unsigned | Condition |
|---|---|---|
| eq | eq | Equal |
| ne | ne | Not equal |
| slt | ult | Less than |
| sge | uge | Greater than or equal |
| sgt | ugt | Greater than |
| sle | ule | Less than or equal |
| of | * | Overflow |
| nof | * | No Overflow |
* The unsigned version of overflow conditions have ISA-specific +semantics and thus have been kept as methods on the TargetIsa trait as +[unsigned_add_overflow_condition][isa::TargetIsa::unsigned_add_overflow_condition] and +[unsigned_sub_overflow_condition][isa::TargetIsa::unsigned_sub_overflow_condition].
+When this instruction compares integer vectors, it returns a boolean +vector of lane-wise comparisons.
+Inputs:
+Outputs:
+fn icmp_imm<T1, T2>(self, Cond: T1, x: Value, Y: T2) -> Value where
T1: Into<IntCC>,
T2: Into<Imm64>, Compare scalar integer to a constant.
+This is the same as the icmp instruction, except one operand is
+an immediate constant.
This instruction can only compare scalars. Use icmp for
+lane-wise vector comparisons.
Inputs:
+Outputs:
+fn ifcmp(self, x: Value, y: Value) -> ValueCompare scalar integers and return flags.
+Compare two scalar integer values and return integer CPU flags +representing the result.
+Inputs:
+Outputs:
+intcc condition code.fn ifcmp_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Compare scalar integer to a constant and return flags.
+Like icmp_imm, but returns integer CPU flags instead of testing
+a specific condition code.
Inputs:
+Outputs:
+intcc condition code.fn iadd(self, x: Value, y: Value) -> ValueWrapping integer addition: a := x + y \pmod{2^B}.
This instruction does not depend on the signed/unsigned interpretation +of the operands.
+Inputs:
+Outputs:
+fn uadd_sat(self, x: Value, y: Value) -> ValueAdd with unsigned saturation.
+This is similar to iadd but the operands are interpreted as unsigned integers and their
+summed result, instead of wrapping, will be saturated to the highest unsigned integer for
+the controlling type (e.g. 0xFF for i8).
Inputs:
+Outputs:
+fn sadd_sat(self, x: Value, y: Value) -> ValueAdd with signed saturation.
+This is similar to iadd but the operands are interpreted as signed integers and their
+summed result, instead of wrapping, will be saturated to the lowest or highest
+signed integer for the controlling type (e.g. 0x80 or 0x7F for i8). For example,
+since an iadd_ssat.i8 of 0x70 and 0x70 is greater than 0x7F, the result will be
+clamped to 0x7F.
Inputs:
+Outputs:
+fn isub(self, x: Value, y: Value) -> ValueWrapping integer subtraction: a := x - y \pmod{2^B}.
This instruction does not depend on the signed/unsigned interpretation +of the operands.
+Inputs:
+Outputs:
+fn usub_sat(self, x: Value, y: Value) -> ValueSubtract with unsigned saturation.
+This is similar to isub but the operands are interpreted as unsigned integers and their
+difference, instead of wrapping, will be saturated to the lowest unsigned integer for
+the controlling type (e.g. 0x00 for i8).
Inputs:
+Outputs:
+fn ssub_sat(self, x: Value, y: Value) -> ValueSubtract with signed saturation.
+This is similar to isub but the operands are interpreted as signed integers and their
+difference, instead of wrapping, will be saturated to the lowest or highest
+signed integer for the controlling type (e.g. 0x80 or 0x7F for i8).
Inputs:
+Outputs:
+fn ineg(self, x: Value) -> ValueInteger negation: a := -x \pmod{2^B}.
Inputs:
+Outputs:
+fn imul(self, x: Value, y: Value) -> ValueWrapping integer multiplication: a := x y \pmod{2^B}.
This instruction does not depend on the signed/unsigned interpretation +of the operands.
+Polymorphic over all integer types (vector and scalar).
+Inputs:
+Outputs:
+fn umulhi(self, x: Value, y: Value) -> ValueUnsigned integer multiplication, producing the high half of a +double-length result.
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn smulhi(self, x: Value, y: Value) -> ValueSigned integer multiplication, producing the high half of a +double-length result.
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn udiv(self, x: Value, y: Value) -> ValueUnsigned integer division: a := \lfloor {x \over y} \rfloor.
This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn sdiv(self, x: Value, y: Value) -> ValueSigned integer division rounded toward zero: a := sign(xy) \lfloor {|x| \over |y|}\rfloor.
This operation traps if the divisor is zero, or if the result is not
+representable in B bits two's complement. This only happens
+when x = -2^{B-1}, y = -1.
Inputs:
+Outputs:
+fn urem(self, x: Value, y: Value) -> ValueUnsigned integer remainder.
+This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn srem(self, x: Value, y: Value) -> ValueSigned integer remainder. The result has the sign of the dividend.
+This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn iadd_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Add immediate integer.
+Same as iadd, but one operand is an immediate constant.
Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn imul_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Integer multiplication by immediate constant.
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn udiv_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Unsigned integer division by an immediate constant.
+This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn sdiv_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Signed integer division by an immediate constant.
+This operation traps if the divisor is zero, or if the result is not
+representable in B bits two's complement. This only happens
+when x = -2^{B-1}, Y = -1.
Inputs:
+Outputs:
+fn urem_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Unsigned integer remainder with immediate divisor.
+This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn srem_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Signed integer remainder with immediate divisor.
+This operation traps if the divisor is zero.
+Inputs:
+Outputs:
+fn irsub_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Immediate reverse wrapping subtraction: a := Y - x \pmod{2^B}.
Also works as integer negation when Y = 0. Use iadd_imm
+with a negative immediate operand for the reverse immediate
+subtraction.
Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn iadd_cin(self, x: Value, y: Value, c_in: Value) -> ValueAdd integers with carry in.
+Same as iadd with an additional carry input. Computes:
a = x + y + c_{in} \pmod 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn iadd_ifcin(self, x: Value, y: Value, c_in: Value) -> ValueAdd integers with carry in.
+Same as iadd with an additional carry flag input. Computes:
a = x + y + c_{in} \pmod 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+intcc condition code.Outputs:
+fn iadd_cout(self, x: Value, y: Value) -> (Value, Value)Add integers with carry out.
+Same as iadd with an additional carry output.
a &= x + y \pmod 2^B \\
+ c_{out} &= x+y >= 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn iadd_ifcout(self, x: Value, y: Value) -> (Value, Value)Add integers with carry out.
+Same as iadd with an additional carry flag output.
a &= x + y \pmod 2^B \\
+ c_{out} &= x+y >= 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+intcc condition code.fn iadd_carry(self, x: Value, y: Value, c_in: Value) -> (Value, Value)Add integers with carry in and out.
+Same as iadd with an additional carry input and output.
a &= x + y + c_{in} \pmod 2^B \\
+ c_{out} &= x + y + c_{in} >= 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn iadd_ifcarry(self, x: Value, y: Value, c_in: Value) -> (Value, Value)Add integers with carry in and out.
+Same as iadd with an additional carry flag input and output.
a &= x + y + c_{in} \pmod 2^B \\
+ c_{out} &= x + y + c_{in} >= 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+intcc condition code.Outputs:
+intcc condition code.fn isub_bin(self, x: Value, y: Value, b_in: Value) -> ValueSubtract integers with borrow in.
+Same as isub with an additional borrow flag input. Computes:
a = x - (y + b_{in}) \pmod 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn isub_ifbin(self, x: Value, y: Value, b_in: Value) -> ValueSubtract integers with borrow in.
+Same as isub with an additional borrow flag input. Computes:
a = x - (y + b_{in}) \pmod 2^B
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+intcc condition code.Outputs:
+fn isub_bout(self, x: Value, y: Value) -> (Value, Value)Subtract integers with borrow out.
+Same as isub with an additional borrow flag output.
a &= x - y \pmod 2^B \\
+ b_{out} &= x < y
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn isub_ifbout(self, x: Value, y: Value) -> (Value, Value)Subtract integers with borrow out.
+Same as isub with an additional borrow flag output.
a &= x - y \pmod 2^B \\
+ b_{out} &= x < y
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+intcc condition code.fn isub_borrow(self, x: Value, y: Value, b_in: Value) -> (Value, Value)Subtract integers with borrow in and out.
+Same as isub with an additional borrow flag input and output.
a &= x - (y + b_{in}) \pmod 2^B \\
+ b_{out} &= x < y + b_{in}
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn isub_ifborrow(self, x: Value, y: Value, b_in: Value) -> (Value, Value)Subtract integers with borrow in and out.
+Same as isub with an additional borrow flag input and output.
a &= x - (y + b_{in}) \pmod 2^B \\
+ b_{out} &= x < y + b_{in}
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+intcc condition code.Outputs:
+intcc condition code.fn band(self, x: Value, y: Value) -> ValueBitwise and.
+Inputs:
+Outputs:
+fn bor(self, x: Value, y: Value) -> ValueBitwise or.
+Inputs:
+Outputs:
+fn bxor(self, x: Value, y: Value) -> ValueBitwise xor.
+Inputs:
+Outputs:
+fn bnot(self, x: Value) -> ValueBitwise not.
+Inputs:
+Outputs:
+fn band_not(self, x: Value, y: Value) -> ValueBitwise and not.
+Computes x & ~y.
Inputs:
+Outputs:
+fn bor_not(self, x: Value, y: Value) -> ValueBitwise or not.
+Computes x | ~y.
Inputs:
+Outputs:
+fn bxor_not(self, x: Value, y: Value) -> ValueBitwise xor not.
+Computes x ^ ~y.
Inputs:
+Outputs:
+fn band_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Bitwise and with immediate.
+Same as band, but one operand is an immediate constant.
Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn bor_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Bitwise or with immediate.
+Same as bor, but one operand is an immediate constant.
Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn bxor_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Bitwise xor with immediate.
+Same as bxor, but one operand is an immediate constant.
Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn rotl(self, x: Value, y: Value) -> ValueRotate left.
+Rotate the bits in x by y places.
Inputs:
+Outputs:
+fn rotr(self, x: Value, y: Value) -> ValueRotate right.
+Rotate the bits in x by y places.
Inputs:
+Outputs:
+fn rotl_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Rotate left by immediate.
+Inputs:
+Outputs:
+fn rotr_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Rotate right by immediate.
+Inputs:
+Outputs:
+fn ishl(self, x: Value, y: Value) -> ValueInteger shift left. Shift the bits in x towards the MSB by y
+places. Shift in zero bits to the LSB.
The shift amount is masked to the size of x.
When shifting a B-bits integer type, this instruction computes:
+ s &:= y \pmod B,
+ a &:= x \cdot 2^s \pmod{2^B}.
+Inputs:
+Outputs:
+fn ushr(self, x: Value, y: Value) -> ValueUnsigned shift right. Shift bits in x towards the LSB by y
+places, shifting in zero bits to the MSB. Also called a logical
+shift.
The shift amount is masked to the size of the register.
+When shifting a B-bits integer type, this instruction computes:
+ s &:= y \pmod B,
+ a &:= \lfloor x \cdot 2^{-s} \rfloor.
+Inputs:
+Outputs:
+fn sshr(self, x: Value, y: Value) -> ValueSigned shift right. Shift bits in x towards the LSB by y
+places, shifting in sign bits to the MSB. Also called an arithmetic
+shift.
The shift amount is masked to the size of the register.
+Inputs:
+Outputs:
+fn ishl_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Integer shift left by immediate.
+The shift amount is masked to the size of x.
Inputs:
+Outputs:
+fn ushr_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Unsigned shift right by immediate.
+The shift amount is masked to the size of the register.
+Inputs:
+Outputs:
+fn sshr_imm<T1>(self, x: Value, Y: T1) -> Value where
T1: Into<Imm64>, Signed shift right by immediate.
+The shift amount is masked to the size of the register.
+Inputs:
+Outputs:
+fn bitrev(self, x: Value) -> ValueReverse the bits of a integer.
+Reverses the bits in x.
Inputs:
+Outputs:
+fn clz(self, x: Value) -> ValueCount leading zero bits.
+Starting from the MSB in x, count the number of zero bits before
+reaching the first one bit. When x is zero, returns the size of x
+in bits.
Inputs:
+Outputs:
+fn cls(self, x: Value) -> ValueCount leading sign bits.
+Starting from the MSB after the sign bit in x, count the number of
+consecutive bits identical to the sign bit. When x is 0 or -1,
+returns one less than the size of x in bits.
Inputs:
+Outputs:
+fn ctz(self, x: Value) -> ValueCount trailing zeros.
+Starting from the LSB in x, count the number of zero bits before
+reaching the first one bit. When x is zero, returns the size of x
+in bits.
Inputs:
+Outputs:
+fn popcnt(self, x: Value) -> ValuePopulation count
+Count the number of one bits in x.
Inputs:
+Outputs:
+fn fcmp<T1>(self, Cond: T1, x: Value, y: Value) -> Value where
T1: Into<FloatCC>, Floating point comparison.
+Two IEEE 754-2008 floating point numbers, x and y, relate to each
+other in exactly one of four ways:
== ==========================================
+UN Unordered when one or both numbers is NaN.
+EQ When x = y. (And 0.0 = -0.0).
+LT When x < y.
+GT When x > y.
+== ==========================================
The 14 floatcc condition codes each correspond to a subset of
+the four relations, except for the empty set which would always be
+false, and the full set which would always be true.
The condition codes are divided into 7 'ordered' conditions which don't +include UN, and 7 unordered conditions which all include UN.
++-------+------------+---------+------------+-------------------------+ +|Ordered |Unordered |Condition | ++=======+============+=========+============+=========================+ +|ord |EQ | LT | GT|uno |UN |NaNs absent / present. | ++-------+------------+---------+------------+-------------------------+ +|eq |EQ |ueq |UN | EQ |Equal | ++-------+------------+---------+------------+-------------------------+ +|one |LT | GT |ne |UN | LT | GT|Not equal | ++-------+------------+---------+------------+-------------------------+ +|lt |LT |ult |UN | LT |Less than | ++-------+------------+---------+------------+-------------------------+ +|le |LT | EQ |ule |UN | LT | EQ|Less than or equal | ++-------+------------+---------+------------+-------------------------+ +|gt |GT |ugt |UN | GT |Greater than | ++-------+------------+---------+------------+-------------------------+ +|ge |GT | EQ |uge |UN | GT | EQ|Greater than or equal | ++-------+------------+---------+------------+-------------------------+
+The standard C comparison operators, <, <=, >, >=, are all ordered,
+so they are false if either operand is NaN. The C equality operator,
+==, is ordered, and since inequality is defined as the logical
+inverse it is unordered. They map to the floatcc condition
+codes as follows:
==== ====== ============
+C Cond Subset
+==== ====== ============
+== eq EQ
+!= ne UN | LT | GT
+< lt LT
+<= le LT | EQ
+> gt GT
+>= ge GT | EQ
+==== ====== ============
This subset of condition codes also corresponds to the WebAssembly +floating point comparisons of the same name.
+When this instruction compares floating point vectors, it returns a +boolean vector with the results of lane-wise comparisons.
+Inputs:
+Outputs:
+fn ffcmp(self, x: Value, y: Value) -> ValueFloating point comparison returning flags.
+Compares two numbers like fcmp, but returns floating point CPU
+flags instead of testing a specific condition.
Inputs:
+Outputs:
+floatcc condition code.fn fadd(self, x: Value, y: Value) -> ValueFloating point addition.
+Inputs:
+Outputs:
+fn fsub(self, x: Value, y: Value) -> ValueFloating point subtraction.
+Inputs:
+Outputs:
+fn fmul(self, x: Value, y: Value) -> ValueFloating point multiplication.
+Inputs:
+Outputs:
+fn fdiv(self, x: Value, y: Value) -> ValueFloating point division.
+Unlike the integer division instructions andudiv`, this can't trap. Division by zero is infinity or
+NaN, depending on the dividend.
Inputs:
+Outputs:
+fn sqrt(self, x: Value) -> ValueFloating point square root.
+Inputs:
+Outputs:
+fn fma(self, x: Value, y: Value, z: Value) -> ValueFloating point fused multiply-and-add.
+Computes a := xy+z without any intermediate rounding of the
+product.
Inputs:
+Outputs:
+fn fneg(self, x: Value) -> ValueFloating point negation.
+Note that this is a pure bitwise operation.
+Inputs:
+Outputs:
+x with its sign bit invertedfn fabs(self, x: Value) -> ValueFloating point absolute value.
+Note that this is a pure bitwise operation.
+Inputs:
+Outputs:
+x with its sign bit clearedfn fcopysign(self, x: Value, y: Value) -> ValueFloating point copy sign.
+Note that this is a pure bitwise operation. The sign bit from y is
+copied to the sign bit of x.
Inputs:
+Outputs:
+x with its sign bit changed to that of yfn fmin(self, x: Value, y: Value) -> ValueFloating point minimum, propagating NaNs.
+If either operand is NaN, this returns a NaN.
+Inputs:
+Outputs:
+x and yfn fmax(self, x: Value, y: Value) -> ValueFloating point maximum, propagating NaNs.
+If either operand is NaN, this returns a NaN.
+Inputs:
+Outputs:
+x and yfn ceil(self, x: Value) -> ValueRound floating point round to integral, towards positive infinity.
+Inputs:
+Outputs:
+x rounded to integral valuefn floor(self, x: Value) -> ValueRound floating point round to integral, towards negative infinity.
+Inputs:
+Outputs:
+x rounded to integral valuefn trunc(self, x: Value) -> ValueRound floating point round to integral, towards zero.
+Inputs:
+Outputs:
+x rounded to integral valuefn nearest(self, x: Value) -> ValueRound floating point round to integral, towards nearest with ties to +even.
+Inputs:
+Outputs:
+x rounded to integral valuefn is_null(self, x: Value) -> ValueReference verification.
+The condition code determines if the reference type in question is +null or not.
+Inputs:
+Outputs:
+fn is_invalid(self, x: Value) -> ValueReference verification.
+The condition code determines if the reference type in question is +invalid or not.
+Inputs:
+Outputs:
+fn trueif<T1>(self, Cond: T1, f: Value) -> Value where
T1: Into<IntCC>, Test integer CPU flags for a specific condition.
+Check the CPU flags in f against the Cond condition code and
+return true when the condition code is satisfied.
Inputs:
+intcc condition code.Outputs:
+fn trueff<T1>(self, Cond: T1, f: Value) -> Value where
T1: Into<FloatCC>, Test floating point CPU flags for a specific condition.
+Check the CPU flags in f against the Cond condition code and
+return true when the condition code is satisfied.
Inputs:
+floatcc condition code.Outputs:
+fn bitcast(self, MemTo: Type, x: Value) -> ValueReinterpret the bits in x as a different type.
The input and output types must be storable to memory and of the same +size. A bitcast is equivalent to storing one type and loading the other +type from the same address.
+Inputs:
+Outputs:
+x reinterpretedfn raw_bitcast(self, AnyTo: Type, x: Value) -> ValueCast the bits in x as a different type of the same bit width.
This instruction does not change the data's representation but allows
+data in registers to be used as different types, e.g. an i32x4 as a
+b8x16. The only constraint on the result a is that it can be
+raw_bitcast back to the original type. Also, in a raw_bitcast between
+vector types with the same number of lanes, the value of each result
+lane is a raw_bitcast of the corresponding operand lane. TODO there is
+currently no mechanism for enforcing the bit width constraint.
Inputs:
+Outputs:
+x reinterpretedfn scalar_to_vector(self, TxN: Type, s: Value) -> ValueScalar To Vector -- move a value out of a scalar register and into a vector register; the +scalar will be moved to the lowest-order bits of the vector register. Note that this +instruction is intended as a low-level legalization instruction and frontends should prefer +insertlane; on certain architectures, scalar_to_vector may zero the highest-order bits for some +types (e.g. integers) but not for others (e.g. floats).
+Inputs:
+Outputs:
+fn breduce(self, BoolTo: Type, x: Value) -> ValueConvert x to a smaller boolean type in the platform-defined way.
The result type must have the same number of vector lanes as the input, +and each lane must not have more bits that the input lanes. If the +input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn bextend(self, BoolTo: Type, x: Value) -> ValueConvert x to a larger boolean type in the platform-defined way.
The result type must have the same number of vector lanes as the input, +and each lane must not have fewer bits that the input lanes. If the +input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn bint(self, IntTo: Type, x: Value) -> ValueConvert x to an integer.
True maps to 1 and false maps to 0. The result type must have the same +number of vector lanes as the input.
+Inputs:
+Outputs:
+fn bmask(self, IntTo: Type, x: Value) -> ValueConvert x to an integer mask.
True maps to all 1s and false maps to all 0s. The result type must have +the same number of vector lanes as the input.
+Inputs:
+Outputs:
+fn ireduce(self, IntTo: Type, x: Value) -> ValueConvert x to a smaller integer type by dropping high bits.
Each lane in x is converted to a smaller integer type by discarding
+the most significant bits. This is the same as reducing modulo
+2^n.
The result type must have the same number of vector lanes as the input, +and each lane must not have more bits that the input lanes. If the +input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn uextend(self, IntTo: Type, x: Value) -> ValueConvert x to a larger integer type by zero-extending.
Each lane in x is converted to a larger integer type by adding
+zeroes. The result has the same numerical value as x when both are
+interpreted as unsigned integers.
The result type must have the same number of vector lanes as the input, +and each lane must not have fewer bits that the input lanes. If the +input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn sextend(self, IntTo: Type, x: Value) -> ValueConvert x to a larger integer type by sign-extending.
Each lane in x is converted to a larger integer type by replicating
+the sign bit. The result has the same numerical value as x when both
+are interpreted as signed integers.
The result type must have the same number of vector lanes as the input, +and each lane must not have fewer bits that the input lanes. If the +input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn fpromote(self, FloatTo: Type, x: Value) -> ValueConvert x to a larger floating point format.
Each lane in x is converted to the destination floating point format.
+This is an exact operation.
Cranelift currently only supports two floating point formats
+f32 and f64. This may change in the future.The result type must have the same number of vector lanes as the input, +and the result lanes must not have fewer bits than the input lanes. If +the input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn fdemote(self, FloatTo: Type, x: Value) -> ValueConvert x to a smaller floating point format.
Each lane in x is converted to the destination floating point format
+by rounding to nearest, ties to even.
Cranelift currently only supports two floating point formats
+f32 and f64. This may change in the future.The result type must have the same number of vector lanes as the input, +and the result lanes must not have more bits than the input lanes. If +the input and output types are the same, this is a no-op.
+Inputs:
+Outputs:
+fn fcvt_to_uint(self, IntTo: Type, x: Value) -> ValueConvert floating point to unsigned integer.
+Each lane in x is converted to an unsigned integer by rounding
+towards zero. If x is NaN or if the unsigned integral value cannot be
+represented in the result type, this instruction traps.
The result type must have the same number of vector lanes as the input.
+Inputs:
+Outputs:
+fn fcvt_to_uint_sat(self, IntTo: Type, x: Value) -> ValueConvert floating point to unsigned integer as fcvt_to_uint does, but +saturates the input instead of trapping. NaN and negative values are +converted to 0.
+Inputs:
+Outputs:
+fn fcvt_to_sint(self, IntTo: Type, x: Value) -> ValueConvert floating point to signed integer.
+Each lane in x is converted to a signed integer by rounding towards
+zero. If x is NaN or if the signed integral value cannot be
+represented in the result type, this instruction traps.
The result type must have the same number of vector lanes as the input.
+Inputs:
+Outputs:
+fn fcvt_to_sint_sat(self, IntTo: Type, x: Value) -> ValueConvert floating point to signed integer as fcvt_to_sint does, but +saturates the input instead of trapping. NaN values are converted to 0.
+Inputs:
+Outputs:
+fn fcvt_from_uint(self, FloatTo: Type, x: Value) -> ValueConvert unsigned integer to floating point.
+Each lane in x is interpreted as an unsigned integer and converted to
+floating point using round to nearest, ties to even.
The result type must have the same number of vector lanes as the input.
+Inputs:
+Outputs:
+fn fcvt_from_sint(self, FloatTo: Type, x: Value) -> ValueConvert signed integer to floating point.
+Each lane in x is interpreted as a signed integer and converted to
+floating point using round to nearest, ties to even.
The result type must have the same number of vector lanes as the input.
+Inputs:
+Outputs:
+fn isplit(self, x: Value) -> (Value, Value)Split an integer into low and high parts.
+Vectors of integers are split lane-wise, so the results have the same +number of lanes as the input, but the lanes are half the size.
+Returns the low half of x and the high half of x as two independent
+values.
Inputs:
+i16 upwardsOutputs:
+xxfn iconcat(self, lo: Value, hi: Value) -> ValueConcatenate low and high bits to form a larger integer type.
+Vectors of integers are concatenated lane-wise such that the result has +the same number of lanes as the inputs, but the lanes are twice the +size.
+Inputs:
+i64i64Outputs:
+lo and hifn x86_udivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)Extended unsigned division.
+Concatenate the bits in nhi and nlo to form the numerator.
+Interpret the bits as an unsigned number and divide by the unsigned
+denominator d. Trap when d is zero or if the quotient is larger
+than the range of the output.
Return both quotient and remainder.
+Inputs:
+Outputs:
+fn x86_sdivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)Extended signed division.
+Concatenate the bits in nhi and nlo to form the numerator.
+Interpret the bits as a signed number and divide by the signed
+denominator d. Trap when d is zero or if the quotient is outside
+the range of the output.
Return both quotient and remainder.
+Inputs:
+Outputs:
+fn x86_umulx(self, argL: Value, argR: Value) -> (Value, Value)Unsigned integer multiplication, producing a double-length result.
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn x86_smulx(self, argL: Value, argR: Value) -> (Value, Value)Signed integer multiplication, producing a double-length result.
+Polymorphic over all scalar integer types, but does not support vector +types.
+Inputs:
+Outputs:
+fn x86_cvtt2si(self, IntTo: Type, x: Value) -> ValueConvert with truncation floating point to signed integer.
+The source floating point operand is converted to a signed integer by +rounding towards zero. If the result can't be represented in the output +type, returns the smallest signed value the output type can represent.
+This instruction does not trap.
+Inputs:
+Outputs:
+fn x86_fmin(self, x: Value, y: Value) -> ValueFloating point minimum with x86 semantics.
+This is equivalent to the C ternary operator x < y ? x : y which
+differs from fmin when either operand is NaN or when comparing
++0.0 to -0.0.
When the two operands don't compare as LT, y is returned unchanged,
+even if it is a signalling NaN.
Inputs:
+Outputs:
+fn x86_fmax(self, x: Value, y: Value) -> ValueFloating point maximum with x86 semantics.
+This is equivalent to the C ternary operator x > y ? x : y which
+differs from fmax when either operand is NaN or when comparing
++0.0 to -0.0.
When the two operands don't compare as GT, y is returned unchanged,
+even if it is a signalling NaN.
Inputs:
+Outputs:
+fn x86_push(self, x: Value) -> InstPushes a value onto the stack.
+Decrements the stack pointer and stores the specified value on to the top.
+This is polymorphic in i32 and i64. However, it is only implemented for i64 +in 64-bit mode, and only for i32 in 32-bit mode.
+Inputs:
+fn x86_pop(self, iWord: Type) -> ValuePops a value from the stack.
+Loads a value from the top of the stack and then increments the stack +pointer.
+This is polymorphic in i32 and i64. However, it is only implemented for i64 +in 64-bit mode, and only for i32 in 32-bit mode.
+Inputs:
+Outputs:
+fn x86_bsr(self, x: Value) -> (Value, Value)Bit Scan Reverse -- returns the bit-index of the most significant 1 +in the word. Result is undefined if the argument is zero. However, it +sets the Z flag depending on the argument, so it is at least easy to +detect and handle that case.
+This is polymorphic in i32 and i64. It is implemented for both i64 and +i32 in 64-bit mode, and only for i32 in 32-bit mode.
+Inputs:
+Outputs:
+intcc condition code.fn x86_bsf(self, x: Value) -> (Value, Value)Bit Scan Forwards -- returns the bit-index of the least significant 1 +in the word. Is otherwise identical to 'bsr', just above.
+Inputs:
+Outputs:
+intcc condition code.fn x86_pshufd<T1>(self, a: Value, i: T1) -> Value where
T1: Into<u8>, Packed Shuffle Doublewords -- copies data from either memory or lanes in an extended +register and re-orders the data according to the passed immediate byte.
+Inputs:
+Outputs:
+fn x86_pshufb(self, a: Value, b: Value) -> ValuePacked Shuffle Bytes -- re-orders data in an extended register using a shuffle +mask from either memory or another extended register
+Inputs:
+Outputs:
+fn x86_pextr<T1>(self, x: Value, Idx: T1) -> Value where
T1: Into<u8>, Extract lane Idx from x.
+The lane index, Idx, is an immediate value, not an SSA value. It
+must indicate a valid lane index for the type of x.
Inputs:
+Outputs:
+fn x86_pinsr<T1>(self, x: Value, Idx: T1, y: Value) -> Value where
T1: Into<u8>, Insert y into x at lane Idx.
+The lane index, Idx, is an immediate value, not an SSA value. It
+must indicate a valid lane index for the type of x.
Inputs:
+Outputs:
+fn x86_insertps<T1>(self, x: Value, Idx: T1, y: Value) -> Value where
T1: Into<u8>, Insert a lane of y into x at using Idx to encode both which lane the value is
+extracted from and which it is inserted to. This is similar to x86_pinsr but inserts
+floats, which are already stored in an XMM register.
Inputs:
+Outputs:
+fn x86_movsd(self, x: Value, y: Value) -> ValueMove the low 64 bits of the float vector y to the low 64 bits of float vector x
Inputs:
+Outputs:
+fn x86_movlhps(self, x: Value, y: Value) -> ValueMove the low 64 bits of the float vector y to the high 64 bits of float vector x
Inputs:
+Outputs:
+fn x86_psll(self, x: Value, y: Value) -> ValueShift Packed Data Left Logical -- This implements the behavior of the shared instruction
+ishl but alters the shift operand to live in an XMM register as expected by the PSLL*
+family of instructions.
Inputs:
+Outputs:
+fn x86_psrl(self, x: Value, y: Value) -> ValueShift Packed Data Right Logical -- This implements the behavior of the shared instruction
+ushr but alters the shift operand to live in an XMM register as expected by the PSRL*
+family of instructions.
Inputs:
+Outputs:
+fn x86_psra(self, x: Value, y: Value) -> ValueShift Packed Data Right Arithmetic -- This implements the behavior of the shared
+instruction sshr but alters the shift operand to live in an XMM register as expected by
+the PSRA* family of instructions.
Inputs:
+Outputs:
+fn x86_ptest(self, x: Value, y: Value) -> ValueLogical Compare -- PTEST will set the ZF flag if all bits in the result are 0 of the +bitwise AND of the first source operand (first operand) and the second source operand +(second operand). PTEST sets the CF flag if all bits in the result are 0 of the bitwise +AND of the second source operand (second operand) and the logical NOT of the destination +operand (first operand).
+Inputs:
+Outputs:
+intcc condition code.fn x86_pmaxs(self, x: Value, y: Value) -> ValueMaximum of Packed Signed Integers -- Compare signed integers in the first and second +operand and return the maximum values.
+Inputs:
+Outputs:
+fn x86_pmaxu(self, x: Value, y: Value) -> ValueMaximum of Packed Unsigned Integers -- Compare unsigned integers in the first and second +operand and return the maximum values.
+Inputs:
+Outputs:
+fn x86_pmins(self, x: Value, y: Value) -> ValueMinimum of Packed Signed Integers -- Compare signed integers in the first and second +operand and return the minimum values.
+Inputs:
+Outputs:
+fn x86_pminu(self, x: Value, y: Value) -> ValueMinimum of Packed Unsigned Integers -- Compare unsigned integers in the first and second +operand and return the minimum values.
+Inputs:
+Outputs:
+fn Binary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)Binary(imms=(), vals=2)
+fn BinaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)BinaryImm(imms=(imm: ir::immediates::Imm64), vals=1)
+fn Branch(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Block,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)Branch(imms=(destination: ir::Block), vals=1)
+fn BranchFloat(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
destination: Block,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)BranchFloat(imms=(cond: ir::condcodes::FloatCC, destination: ir::Block), vals=1)
+fn BranchIcmp(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Block,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)BranchIcmp(imms=(cond: ir::condcodes::IntCC, destination: ir::Block), vals=2)
+fn BranchInt(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Block,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)BranchInt(imms=(cond: ir::condcodes::IntCC, destination: ir::Block), vals=1)
+fn BranchTable(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Block,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)BranchTable(imms=(destination: ir::Block, table: ir::JumpTable), vals=1)
+fn BranchTableBase(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable
) -> (Inst, &'f mut DataFlowGraph)BranchTableBase(imms=(table: ir::JumpTable), vals=0)
+fn BranchTableEntry(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: u8,
table: JumpTable,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)BranchTableEntry(imms=(imm: ir::immediates::Uimm8, table: ir::JumpTable), vals=2)
+fn Call(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)Call(imms=(func_ref: ir::FuncRef), vals=0)
+fn CallIndirect(
self,
opcode: Opcode,
ctrl_typevar: Type,
sig_ref: SigRef,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)CallIndirect(imms=(sig_ref: ir::SigRef), vals=1)
+fn CondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)CondTrap(imms=(code: ir::TrapCode), vals=1)
+fn CopySpecial(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: u16,
dst: u16
) -> (Inst, &'f mut DataFlowGraph)CopySpecial(imms=(src: isa::RegUnit, dst: isa::RegUnit), vals=0)
+fn CopyToSsa(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: u16
) -> (Inst, &'f mut DataFlowGraph)CopyToSsa(imms=(src: isa::RegUnit), vals=0)
+fn ExtractLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: u8,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)ExtractLane(imms=(lane: ir::immediates::Uimm8), vals=1)
+fn FloatCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)FloatCompare(imms=(cond: ir::condcodes::FloatCC), vals=2)
+fn FloatCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)FloatCond(imms=(cond: ir::condcodes::FloatCC), vals=1)
+fn FloatCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)FloatCondTrap(imms=(cond: ir::condcodes::FloatCC, code: ir::TrapCode), vals=1)
+fn FuncAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef
) -> (Inst, &'f mut DataFlowGraph)FuncAddr(imms=(func_ref: ir::FuncRef), vals=0)
+fn HeapAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
heap: Heap,
imm: Uimm32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)HeapAddr(imms=(heap: ir::Heap, imm: ir::immediates::Uimm32), vals=1)
+fn IndirectJump(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)IndirectJump(imms=(table: ir::JumpTable), vals=1)
+fn InsertLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: u8,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)InsertLane(imms=(lane: ir::immediates::Uimm8), vals=2)
+fn IntCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)IntCompare(imms=(cond: ir::condcodes::IntCC), vals=2)
+fn IntCompareImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)IntCompareImm(imms=(cond: ir::condcodes::IntCC, imm: ir::immediates::Imm64), vals=1)
+fn IntCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)IntCond(imms=(cond: ir::condcodes::IntCC), vals=1)
+fn IntCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)IntCondTrap(imms=(cond: ir::condcodes::IntCC, code: ir::TrapCode), vals=1)
+fn IntSelect(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)IntSelect(imms=(cond: ir::condcodes::IntCC), vals=3)
+fn Jump(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Block,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)Jump(imms=(destination: ir::Block), vals=0)
+fn Load(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)Load(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=1)
+fn LoadComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)LoadComplex(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=0)
+fn MultiAry(
self,
opcode: Opcode,
ctrl_typevar: Type,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)MultiAry(imms=(), vals=0)
+fn NullAry(
self,
opcode: Opcode,
ctrl_typevar: Type
) -> (Inst, &'f mut DataFlowGraph)NullAry(imms=(), vals=0)
+fn RegFill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: StackSlot,
dst: u16,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)RegFill(imms=(src: ir::StackSlot, dst: isa::RegUnit), vals=1)
+fn RegMove(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: u16,
dst: u16,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)RegMove(imms=(src: isa::RegUnit, dst: isa::RegUnit), vals=1)
+fn RegSpill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: u16,
dst: StackSlot,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)RegSpill(imms=(src: isa::RegUnit, dst: ir::StackSlot), vals=1)
+fn Shuffle(
self,
opcode: Opcode,
ctrl_typevar: Type,
mask: Immediate,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)Shuffle(imms=(mask: ir::Immediate), vals=2)
+fn StackLoad(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32
) -> (Inst, &'f mut DataFlowGraph)StackLoad(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=0)
+fn StackStore(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)StackStore(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=1)
+fn Store(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)Store(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=2)
+fn StoreComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: EntityList<Value>
) -> (Inst, &'f mut DataFlowGraph)StoreComplex(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=1)
+fn TableAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: Table,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)TableAddr(imms=(table: ir::Table, offset: ir::immediates::Offset32), vals=1)
+fn Ternary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)Ternary(imms=(), vals=3)
+fn Trap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode
) -> (Inst, &'f mut DataFlowGraph)Trap(imms=(code: ir::TrapCode), vals=0)
+fn Unary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)Unary(imms=(), vals=1)
+fn UnaryBool(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: bool
) -> (Inst, &'f mut DataFlowGraph)UnaryBool(imms=(imm: bool), vals=0)
+fn UnaryConst(
self,
opcode: Opcode,
ctrl_typevar: Type,
constant_handle: Constant
) -> (Inst, &'f mut DataFlowGraph)UnaryConst(imms=(constant_handle: ir::Constant), vals=0)
+fn UnaryGlobalValue(
self,
opcode: Opcode,
ctrl_typevar: Type,
global_value: GlobalValue
) -> (Inst, &'f mut DataFlowGraph)UnaryGlobalValue(imms=(global_value: ir::GlobalValue), vals=0)
+fn UnaryIeee32(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee32
) -> (Inst, &'f mut DataFlowGraph)UnaryIeee32(imms=(imm: ir::immediates::Ieee32), vals=0)
+fn UnaryIeee64(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee64
) -> (Inst, &'f mut DataFlowGraph)UnaryIeee64(imms=(imm: ir::immediates::Ieee64), vals=0)
+fn UnaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64
) -> (Inst, &'f mut DataFlowGraph)UnaryImm(imms=(imm: ir::immediates::Imm64), vals=0)
+impl<'f, T> InstBuilder<'f> for T where
T: InstBuilderBase<'f>, Any type implementing InstBuilderBase gets all the InstBuilder methods for free.
Persistent data structures and compilation pipeline.
+func: FunctionThe function we're compiling.
+cfg: ControlFlowGraphThe control flow graph of func.
domtree: DominatorTreeDominator tree for func.
regalloc: ContextRegister allocation context.
+loop_analysis: LoopAnalysisLoop analysis of func.
redundant_reload_remover: RedundantReloadRemoverRedundant-reload remover context.
+impl Contextpub fn new() -> ContextAllocate a new compilation context.
+The returned instance should be reused for compiling multiple functions in order to avoid +needless allocator thrashing.
+pub fn for_function(func: Function) -> ContextAllocate a new compilation context with an existing Function.
+The returned instance should be reused for compiling multiple functions in order to avoid +needless allocator thrashing.
+pub fn clear(&mut self)Clear all data structures in this context.
+pub fn compile_and_emit(
&mut self,
isa: &dyn TargetIsa,
mem: &mut Vec<u8>,
relocs: &mut dyn RelocSink,
traps: &mut dyn TrapSink,
stackmaps: &mut dyn StackmapSink
) -> Result<CodeInfo, CodegenError>Compile the function, and emit machine code into a Vec<u8>.
Run the function through all the passes necessary to generate code for the target ISA
+represented by isa, as well as the final step of emitting machine code into a
+Vec<u8>. The machine code is not relocated. Instead, any relocations are emitted
+into relocs.
This function calls compile and emit_to_memory, taking care to resize mem as
+needed, so it provides a safe interface.
Returns information about the function's code and read-only data.
+pub fn compile(&mut self, isa: &dyn TargetIsa) -> Result<CodeInfo, CodegenError>Compile the function.
+Run the function through all the passes necessary to generate code for the target ISA
+represented by isa. This does not include the final step of emitting machine code into a
+code sink.
Returns information about the function's code and read-only data.
+pub unsafe fn emit_to_memory(
&self,
isa: &dyn TargetIsa,
mem: *mut u8,
relocs: &mut dyn RelocSink,
traps: &mut dyn TrapSink,
stackmaps: &mut dyn StackmapSink
) -> CodeInfoEmit machine code directly into raw memory.
+Write all of the function's machine code to the memory at mem. The size of the machine
+code is returned by compile above.
The machine code is not relocated. Instead, any relocations are emitted into relocs.
This function is unsafe since it does not perform bounds checking on the memory buffer,
+and it can't guarantee that the mem pointer is valid.
Returns information about the emitted code and data.
+pub fn emit_unwind_info(
&self,
isa: &dyn TargetIsa,
kind: FrameUnwindKind,
sink: &mut dyn FrameUnwindSink
)Emit unwind information.
+Requires that the function layout be calculated (see relax_branches).
Only some calling conventions (e.g. Windows fastcall) will have unwind information. +This is a no-op if the function has no unwind information.
+pub fn verify<'a, FOI>(&self, fisa: FOI) -> Result<(), VerifierErrors> where
FOI: Into<FlagsOrIsa<'a>>, Run the verifier on the function.
+Also check that the dominator tree and control flow graph are consistent with the function.
+pub fn verify_if<'a, FOI>(&self, fisa: FOI) -> Result<(), CodegenError> where
FOI: Into<FlagsOrIsa<'a>>, Run the verifier only if the enable_verifier setting is true.
pub fn verify_locations(
&self,
isa: &dyn TargetIsa
) -> Result<(), VerifierErrors>Run the locations verifier on the function.
+pub fn verify_locations_if(
&self,
isa: &dyn TargetIsa
) -> Result<(), CodegenError>Run the locations verifier only if the enable_verifier setting is true.
pub fn dce<'a, FOI>(&mut self, fisa: FOI) -> Result<(), CodegenError> where
FOI: Into<FlagsOrIsa<'a>>, Perform dead-code elimination on the function.
+pub fn preopt(&mut self, isa: &dyn TargetIsa) -> Result<(), CodegenError>Perform pre-legalization rewrites on the function.
+pub fn canonicalize_nans(
&mut self,
isa: &dyn TargetIsa
) -> Result<(), CodegenError>Perform NaN canonicalizing rewrites on the function.
+pub fn legalize(&mut self, isa: &dyn TargetIsa) -> Result<(), CodegenError>Run the legalizer for isa on the function.
pub fn postopt(&mut self, isa: &dyn TargetIsa) -> Result<(), CodegenError>Perform post-legalization rewrites on the function.
+pub fn compute_cfg(&mut self)Compute the control flow graph.
+pub fn compute_domtree(&mut self)Compute dominator tree.
+pub fn compute_loop_analysis(&mut self)Compute the loop analysis.
+pub fn flowgraph(&mut self)Compute the control flow graph and dominator tree.
+pub fn simple_gvn<'a, FOI>(&mut self, fisa: FOI) -> Result<(), CodegenError> where
FOI: Into<FlagsOrIsa<'a>>, Perform simple GVN on the function.
+pub fn licm(&mut self, isa: &dyn TargetIsa) -> Result<(), CodegenError>Perform LICM on the function.
+pub fn eliminate_unreachable_code<'a, FOI>(
&mut self,
fisa: FOI
) -> Result<(), CodegenError> where
FOI: Into<FlagsOrIsa<'a>>, Perform unreachable code elimination.
+pub fn regalloc(&mut self, isa: &dyn TargetIsa) -> Result<(), CodegenError>Run the register allocator.
+pub fn prologue_epilogue(
&mut self,
isa: &dyn TargetIsa
) -> Result<(), CodegenError>Insert prologue and epilogues after computing the stack frame layout.
+pub fn redundant_reload_remover(
&mut self,
isa: &dyn TargetIsa
) -> Result<(), CodegenError>Do redundant-reload removal after allocation of both registers and stack slots.
+pub fn shrink_instructions(
&mut self,
isa: &dyn TargetIsa
) -> Result<(), CodegenError>Run the instruction shrinking pass.
+pub fn relax_branches(
&mut self,
isa: &dyn TargetIsa
) -> Result<CodeInfo, CodegenError>Run the branch relaxation pass and return information about the function's code and +read-only data.
+pub fn build_value_labels_ranges(
&self,
isa: &dyn TargetIsa
) -> Result<HashMap<ValueLabel, Vec<ValueLocRange>, RandomState>, CodegenError>Builds ranges and location for specified value labels.
+impl RefUnwindSafe for Contextimpl !Send for Contextimpl !Sync for Contextimpl Unpin for Contextimpl UnwindSafe for Contextimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Temporary object used to build a single Cranelift IR Function.
func: &'a mut FunctionThe function currently being built. +This field is public so the function can be re-borrowed.
+impl<'a> FunctionBuilder<'a>This module allows you to create a function in Cranelift IR in a straightforward way, hiding +all the complexity of its internal representation.
+The module is parametrized by one type which is the representation of variables in your
+origin language. It offers a way to conveniently append instruction to your program flow.
+You are responsible to split your instruction flow into extended blocks (declared with
+create_block) whose properties are:
The parameters of Cranelift IR instructions are Cranelift IR values, which can only be created
+as results of other Cranelift IR instructions. To be able to create variables redefined multiple
+times in your program, use the def_var and use_var command, that will maintain the
+correspondence between your variables and Cranelift IR SSA values.
The first block for which you call switch_to_block will be assumed to be the beginning of
+the function.
At creation, a FunctionBuilder instance borrows an already allocated Function which it
+modifies with the information stored in the mutable borrowed
+FunctionBuilderContext. The function passed in
+argument should be newly created with
+Function::with_name_signature(), whereas the
+FunctionBuilderContext can be kept as is between two function translations.
The functions below will panic in debug mode whenever you try to modify the Cranelift IR
+function in a way that violate the coherence of the code. For instance: switching to a new
+Block when you haven't filled the current one with a terminator instruction, inserting a
+return instruction with arguments that don't match the function's signature.
pub fn new(
func: &'a mut Function,
func_ctx: &'a mut FunctionBuilderContext
) -> FunctionBuilder<'a>Creates a new FunctionBuilder structure that will operate on a Function using a
+FunctionBuilderContext.
pub fn set_srcloc(&mut self, srcloc: SourceLoc)Set the source location that should be assigned to all new instructions.
+pub fn create_block(&mut self) -> BlockCreates a new Block and returns its reference.
pub fn switch_to_block(&mut self, block: Block)After the call to this function, new instructions will be inserted into the designated +block, in the order they are declared. You must declare the types of the Block arguments +you will use here.
+When inserting the terminator instruction (which doesn't have a fallthrough to its immediate +successor), the block will be declared filled and it will not be possible to append +instructions to it.
+pub fn seal_block(&mut self, block: Block)Declares that all the predecessors of this block are known.
+Function to call with block as soon as the last branch instruction to block has been
+created. Forgetting to call this method on every block will cause inconsistencies in the
+produced functions.
pub fn seal_all_blocks(&mut self)Effectively calls seal_block on all blocks in the function.
+It's more efficient to seal Blocks as soon as possible, during
+translation, but for frontends where this is impractical to do, this
+function can be used at the end of translating all blocks to ensure
+that everything is sealed.
pub fn declare_var(&mut self, var: Variable, ty: Type)In order to use a variable in a use_var, you need to declare its type with this method.
pub fn use_var(&mut self, var: Variable) -> ValueReturns the Cranelift IR value corresponding to the utilization at the current program +position of a previously defined user variable.
+pub fn def_var(&mut self, var: Variable, val: Value)Register a new definition of a user variable. The type of the value must be +the same as the type registered for the variable.
+pub fn set_val_label(&mut self, val: Value, label: ValueLabel)Set label for Value
+This will not do anything unless func.dfg.collect_debug_info is called first.
pub fn create_jump_table(&mut self, data: JumpTableData) -> JumpTableCreates a jump table in the function, to be used by br_table instructions.
pub fn create_stack_slot(&mut self, data: StackSlotData) -> StackSlotCreates a stack slot in the function, to be used by stack_load, stack_store and
+stack_addr instructions.
pub fn import_signature(&mut self, signature: Signature) -> SigRefAdds a signature which can later be used to declare an external function import.
+pub fn import_function(&mut self, data: ExtFuncData) -> FuncRefDeclare an external function import.
+pub fn create_global_value(&mut self, data: GlobalValueData) -> GlobalValueDeclares a global value accessible to the function.
+pub fn create_heap(&mut self, data: HeapData) -> HeapDeclares a heap accessible to the function.
+pub fn ins(&'short mut self) -> FuncInstBuilder<'short, 'a>Returns an object with the InstBuilder
+trait that allows to conveniently append an instruction to the current Block being built.
pub fn ensure_inserted_block(&mut self)Make sure that the current block is inserted in the layout.
+pub fn cursor(&mut self) -> FuncCursorReturns a FuncCursor pointed at the current position ready for inserting instructions.
This can be used to insert SSA code that doesn't need to access locals and that doesn't
+need to know about FunctionBuilder at all.
pub fn append_block_params_for_function_params(&mut self, block: Block)Append parameters to the given Block corresponding to the function
+parameters. This can be used to set up the block parameters for the
+entry block.
pub fn append_block_params_for_function_returns(&mut self, block: Block)Append parameters to the given Block corresponding to the function
+return values. This can be used to set up the block parameters for a
+function exit block.
pub fn finalize(&mut self)Declare that translation of the current function is complete. This
+resets the state of the FunctionBuilder in preparation to be used
+for another function.
impl<'a> FunctionBuilder<'a>All the functions documented in the previous block are write-only and help you build a valid +Cranelift IR functions via multiple debug asserts. However, you might need to improve the +performance of your translation perform more complex transformations to your Cranelift IR +function. The functions below help you inspect the function you're creating and modify it +in ways that can be unsafe if used incorrectly.
+pub fn block_params(&self, block: Block) -> &[Value]Retrieves all the parameters for a Block currently inferred from the jump instructions
+inserted that target it and the SSA construction.
pub fn signature(&self, sigref: SigRef) -> Option<&Signature>Retrieves the signature with reference sigref previously added with import_signature.
pub fn append_block_param(&mut self, block: Block, ty: Type) -> ValueCreates a parameter for a specific Block by appending it to the list of already existing
+parameters.
Note: this function has to be called at the creation of the Block before adding
+instructions to it, otherwise this could interfere with SSA construction.
pub fn inst_results(&self, inst: Inst) -> &[Value]Returns the result values of an instruction.
+pub fn change_jump_destination(&mut self, inst: Inst, new_dest: Block)Changes the destination of a jump instruction after creation.
+Note: You are responsible for maintaining the coherence with the arguments of +other jump instructions.
+pub fn is_unreachable(&self) -> boolReturns true if and only if the current Block is sealed and has no predecessors declared.
The entry block of a function is never unreachable.
+pub fn is_pristine(&self) -> boolReturns true if and only if no instructions have been added since the last call to
+switch_to_block.
pub fn is_filled(&self) -> boolReturns true if and only if a terminator instruction has been inserted since the
+last call to switch_to_block.
pub fn display<'b, I>(&'b self, isa: I) -> DisplayFunction<'b> where
I: Into<Option<&'b (dyn TargetIsa + 'b)>>, Returns a displayable object for the function as it is.
+Useful for debug purposes. Use it with None for standard printing.
impl<'a> FunctionBuilder<'a>Helper functions
+pub fn call_memcpy(
&mut self,
config: TargetFrontendConfig,
dest: Value,
src: Value,
size: Value
)Calls libc.memcpy
+Copies the size bytes from src to dest, assumes that src + size
+won't overlap onto dest. If dest and src overlap, the behavior is
+undefined. Applications in which dest and src might overlap should
+use call_memmove instead.
pub fn emit_small_memcpy(
&mut self,
config: TargetFrontendConfig,
dest: Value,
src: Value,
size: u64,
dest_align: u8,
src_align: u8
)Optimised memcpy for small copies.
+pub fn call_memset(
&mut self,
config: TargetFrontendConfig,
buffer: Value,
ch: Value,
size: Value
)Calls libc.memset
+Writes size bytes of i8 value ch to memory starting at buffer.
pub fn emit_small_memset(
&mut self,
config: TargetFrontendConfig,
buffer: Value,
ch: u8,
size: u64,
buffer_align: u8
)Calls libc.memset
+Writes size bytes of value ch to memory starting at buffer.
pub fn call_memmove(
&mut self,
config: TargetFrontendConfig,
dest: Value,
source: Value,
size: Value
)Calls libc.memmove
+Copies size bytes from memory starting at source to memory starting
+at dest. source is always read before writing to dest.
pub fn emit_small_memmove(
&mut self,
config: TargetFrontendConfig,
dest: Value,
src: Value,
size: u64,
dest_align: u8,
src_align: u8
)Optimised memmove for small moves.
+impl<'a> RefUnwindSafe for FunctionBuilder<'a>impl<'a> Send for FunctionBuilder<'a>impl<'a> Sync for FunctionBuilder<'a>impl<'a> Unpin for FunctionBuilder<'a>impl<'a> !UnwindSafe for FunctionBuilder<'a>impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Structure used for translating a series of functions into Cranelift IR.
+In order to reduce memory reallocations when compiling multiple functions,
+FunctionBuilderContext holds various data structures which are cleared between
+functions, rather than dropped, preserving the underlying allocations.
impl FunctionBuilderContextpub fn new() -> FunctionBuilderContextCreates a FunctionBuilderContext structure. The structure is automatically cleared after
+each FunctionBuilder completes translating a function.
impl RefUnwindSafe for FunctionBuilderContextimpl Send for FunctionBuilderContextimpl Sync for FunctionBuilderContextimpl Unpin for FunctionBuilderContextimpl UnwindSafe for FunctionBuilderContextimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub const VERSION: &str = env!("CARGO_PKG_VERSION");
Version number of this crate.
+pub fn emit_module(
obj: &mut Artifact,
module: &Module,
compilation: &Compilation,
relocations: &Relocations,
data_initializers: &[DataInitializer],
target_config: &TargetFrontendConfig
) -> Result<()>
Emits a module that has been emitted with the wasmtime-environ environment
+implementation to a native object file.
Object-file writing library using the wasmtime environment.
+| VERSION | Version number of this crate. + |
| emit_module | Emits a module that has been emitted with the |
Redirecting to ../../wasmtime_obj/fn.emit_module.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_obj/sidebar-items.js b/api/wasmtime_obj/sidebar-items.js new file mode 100644 index 000000000000..3224fac68b50 --- /dev/null +++ b/api/wasmtime_obj/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"constant":[["VERSION","Version number of this crate."]],"fn":[["emit_module","Emits a module that has been emitted with the `wasmtime-environ` environment implementation to a native object file."]]}); \ No newline at end of file diff --git a/api/wasmtime_runtime/all.html b/api/wasmtime_runtime/all.html new file mode 100644 index 000000000000..12418ae62cca --- /dev/null +++ b/api/wasmtime_runtime/all.html @@ -0,0 +1,3 @@ +pub const VERSION: &str = env!("CARGO_PKG_VERSION");
Version number of this crate.
+The value of an export passed from one instance to another.
+A function export value.
+address: *const VMFunctionBodyThe address of the native-code function.
+vmctx: *mut VMContextPointer to the containing VMContext.
signature: SignatureThe function signature declaration, used for compatibilty checking.
+A table export value.
+definition: *mut VMTableDefinitionThe address of the table descriptor.
+vmctx: *mut VMContextPointer to the containing VMContext.
table: TablePlanThe table declaration, used for compatibilty checking.
+A memory export value.
+definition: *mut VMMemoryDefinitionThe address of the memory descriptor.
+vmctx: *mut VMContextPointer to the containing VMContext.
memory: MemoryPlanThe memory declaration, used for compatibilty checking.
+A global export value.
+definition: *mut VMGlobalDefinitionThe address of the global storage.
+vmctx: *mut VMContextPointer to the containing VMContext.
global: GlobalThe global declaration, used for compatibilty checking.
+impl Export[src]pub fn function(
address: *const VMFunctionBody,
vmctx: *mut VMContext,
signature: Signature
) -> Self[src]Construct a function export value.
+pub fn table(
definition: *mut VMTableDefinition,
vmctx: *mut VMContext,
table: TablePlan
) -> Self[src]Construct a table export value.
+pub fn memory(
definition: *mut VMMemoryDefinition,
vmctx: *mut VMContext,
memory: MemoryPlan
) -> Self[src]Construct a memory export value.
+pub fn global(
definition: *mut VMGlobalDefinition,
vmctx: *mut VMContext,
global: Global
) -> Self[src]Construct a global export value.
+impl RefUnwindSafe for Exportimpl !Send for Exportimpl !Sync for Exportimpl Unpin for Exportimpl UnwindSafe for Exportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An error while instantiating a module.
+Resource(String)Insufficient resources available for execution.
+Link(LinkError)A wasm link error occured.
+StartTrap(Trap)A compilation error occured.
+impl Debug for InstantiationError[src]impl Display for InstantiationError[src]impl Error for InstantiationError[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<LinkError> for InstantiationError[src]impl !RefUnwindSafe for InstantiationErrorimpl Send for InstantiationErrorimpl Sync for InstantiationErrorimpl Unpin for InstantiationErrorimpl !UnwindSafe for InstantiationErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Stores trace message with backtrace.
+A user-raised trap through raise_user_trap.
A wasm-originating trap from wasm code itself.
+desc: TrapDescriptionWhat sort of trap happened, as well as where in the original wasm module +it happened.
+backtrace: BacktraceNative stack backtrace at the time the trap occurred
+impl !RefUnwindSafe for Trapimpl Send for Trapimpl Sync for Trapimpl Unpin for Trapimpl !UnwindSafe for Trapimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime_runtime/enum.Export.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/fn.catch_traps.html b/api/wasmtime_runtime/fn.catch_traps.html new file mode 100644 index 000000000000..0f269d8344fc --- /dev/null +++ b/api/wasmtime_runtime/fn.catch_traps.html @@ -0,0 +1,4 @@ +pub unsafe fn catch_traps<F>(
vmctx: *mut VMContext,
closure: F
) -> Result<(), Trap> where
F: FnMut(),
Catches any wasm traps that happen within the execution of closure,
+returning them as a Result.
Highly unsafe since closure won't have any dtors run.
pub unsafe fn raise_user_trap(data: Box<dyn Error + Send + Sync>) -> !
Raises a user-defined trap immediately.
+This function performs as-if a wasm trap was just executed, only the trap
+has a dynamic payload associated with it which is user-provided. This trap
+payload is then returned from wasmtime_call an wasmtime_call_trampoline
+below.
Only safe to call when wasm code is on the stack, aka wasmtime_call or
+wasmtime_call_trampoline must have been previously called.
pub unsafe fn resume_panic(payload: Box<dyn Any + Send>) -> !
Carries a Rust panic across wasm code and resumes the panic on the other +side.
+Only safe to call when wasm code is on the stack, aka wasmtime_call or
+wasmtime_call_trampoline must have been previously called.
pub unsafe fn wasmtime_call_trampoline(
vmctx: *mut VMContext,
caller_vmctx: *mut VMContext,
trampoline: *const VMFunctionBody,
callee: *const VMFunctionBody,
values_vec: *mut u8
) -> Result<(), Trap>
Call the wasm function pointed to by callee.
vmctx - the callee vmctx argumentcaller_vmctx - the caller vmctx argumenttrampoline - the jit-generated trampoline whose ABI takes 4 values, the
+callee vmctx, the caller vmctx, the callee argument below, and then the
+values_vec argument.callee - the third argument to the trampoline functionvalues_vec - points to a buffer which holds the incoming arguments, and to
+which the outgoing return values will be written.Wildly unsafe because it calls raw function pointers and reads/writes raw +function pointers.
+Redirecting to ../../wasmtime_runtime/struct.Imports.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/index.html b/api/wasmtime_runtime/index.html new file mode 100644 index 000000000000..8661f73aa00d --- /dev/null +++ b/api/wasmtime_runtime/index.html @@ -0,0 +1,60 @@ +Runtime library support for Wasmtime.
+| libcalls | Runtime library calls. Note that wasm compilers may sometimes perform these +inline rather than calling them, particularly when CPUs have special +instructions which compute them directly. + |
| GdbJitImageRegistration | Registeration for JIT image + |
| Imports | Resolved import pointers. + |
| InstanceHandle | A handle holding an |
| LinkError | An link error while instantiating a module. + |
| Mmap | A simple struct consisting of a page-aligned pointer to page-aligned +and initially-zeroed memory and a length. + |
| SignatureRegistry | WebAssembly requires that the caller and callee signatures in an indirect +call must match. To implement this efficiently, keep a registry of all +signatures, shared by all instances, so that call sites can just do an +index comparison. + |
| TrapDescription | Description of a trap. + |
| TrapRegistration | RAII structure returned from |
| TrapRegistry | The registry maintains descriptions of traps in currently allocated functions. + |
| VMCallerCheckedAnyfunc | The VM caller-checked "anyfunc" record, for caller-side signature checking. +It consists of the actual function pointer and a signature id to be checked +by the caller. + |
| VMContext | The VM "context", which is pointed to by the |
| VMFunctionBody | A placeholder byte-sized type which is just used to provide some amount of type +safety when dealing with pointers to JIT-compiled function bodies. Note that it's +deliberately not Copy, as we shouldn't be carelessly copying function body bytes +around. + |
| VMFunctionImport | An imported function. + |
| VMGlobalDefinition | The storage for a WebAssembly global defined within the instance. + |
| VMGlobalImport | The fields compiled code needs to access to utilize a WebAssembly global +variable imported from another instance. + |
| VMInvokeArgument | The storage for a WebAssembly invocation argument + |
| VMMemoryDefinition | The fields compiled code needs to access to utilize a WebAssembly linear +memory defined within the instance, namely the start address and the +size in bytes. + |
| VMMemoryImport | The fields compiled code needs to access to utilize a WebAssembly linear +memory imported from another instance. + |
| VMSharedSignatureIndex | An index into the shared signature registry, usable for checking signatures +at indirect calls. + |
| VMTableDefinition | The fields compiled code needs to access to utilize a WebAssembly table +defined within the instance. + |
| VMTableImport | The fields compiled code needs to access to utilize a WebAssembly table +imported from another instance. + |
| Export | The value of an export passed from one instance to another. + |
| InstantiationError | An error while instantiating a module. + |
| Trap | Stores trace message with backtrace. + |
| VERSION | Version number of this crate. + |
| catch_traps⚠ | Catches any wasm traps that happen within the execution of |
| raise_user_trap⚠ | Raises a user-defined trap immediately. + |
| resume_panic⚠ | Carries a Rust panic across wasm code and resumes the panic on the other +side. + |
| wasmtime_call_trampoline⚠ | Call the wasm function pointed to by |
Redirecting to ../../wasmtime_runtime/enum.InstantiationError.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/instance/struct.InstanceHandle.html b/api/wasmtime_runtime/instance/struct.InstanceHandle.html new file mode 100644 index 000000000000..179dd73c9989 --- /dev/null +++ b/api/wasmtime_runtime/instance/struct.InstanceHandle.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.InstanceHandle.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/instance/struct.LinkError.html b/api/wasmtime_runtime/instance/struct.LinkError.html new file mode 100644 index 000000000000..f6665db90b32 --- /dev/null +++ b/api/wasmtime_runtime/instance/struct.LinkError.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.LinkError.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/jit_int/struct.GdbJitImageRegistration.html b/api/wasmtime_runtime/jit_int/struct.GdbJitImageRegistration.html new file mode 100644 index 000000000000..fabaf9514416 --- /dev/null +++ b/api/wasmtime_runtime/jit_int/struct.GdbJitImageRegistration.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.GdbJitImageRegistration.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/libcalls/fn.wasmtime_f32_ceil.html b/api/wasmtime_runtime/libcalls/fn.wasmtime_f32_ceil.html new file mode 100644 index 000000000000..4c1ff5933f1d --- /dev/null +++ b/api/wasmtime_runtime/libcalls/fn.wasmtime_f32_ceil.html @@ -0,0 +1,2 @@ +pub extern "C" fn wasmtime_f32_ceil(x: f32) -> f32
Implementation of f32.ceil
+pub extern "C" fn wasmtime_f32_floor(x: f32) -> f32
Implementation of f32.floor
+pub extern "C" fn wasmtime_f32_nearest(x: f32) -> f32
Implementation of f32.nearest
+pub extern "C" fn wasmtime_f32_trunc(x: f32) -> f32
Implementation of f32.trunc
+pub extern "C" fn wasmtime_f64_ceil(x: f64) -> f64
Implementation of f64.ceil
+pub extern "C" fn wasmtime_f64_floor(x: f64) -> f64
Implementation of f64.floor
+pub extern "C" fn wasmtime_f64_nearest(x: f64) -> f64
Implementation of f64.nearest
+pub extern "C" fn wasmtime_f64_trunc(x: f64) -> f64
Implementation of f64.trunc
+#[no_mangle] +pub unsafe extern "C" fn wasmtime_imported_memory32_grow(
vmctx: *mut VMContext,
delta: u32,
memory_index: u32
) -> u32
Implementation of memory.grow for imported 32-bit memories.
+#[no_mangle] +pub unsafe extern "C" fn wasmtime_imported_memory32_size(
vmctx: *mut VMContext,
memory_index: u32
) -> u32
Implementation of memory.size for imported 32-bit memories.
+#[no_mangle] +pub unsafe extern "C" fn wasmtime_memory32_grow(
vmctx: *mut VMContext,
delta: u32,
memory_index: u32
) -> u32
Implementation of memory.grow for locally-defined 32-bit memories.
+#[no_mangle] +pub unsafe extern "C" fn wasmtime_memory32_size(
vmctx: *mut VMContext,
memory_index: u32
) -> u32
Implementation of memory.size for locally-defined 32-bit memories.
+Runtime library calls. Note that wasm compilers may sometimes perform these +inline rather than calling them, particularly when CPUs have special +instructions which compute them directly.
+| wasmtime_f32_ceil | Implementation of f32.ceil + |
| wasmtime_f32_floor | Implementation of f32.floor + |
| wasmtime_f32_trunc | Implementation of f32.trunc + |
| wasmtime_f32_nearest | Implementation of f32.nearest + |
| wasmtime_f64_ceil | Implementation of f64.ceil + |
| wasmtime_f64_floor | Implementation of f64.floor + |
| wasmtime_f64_trunc | Implementation of f64.trunc + |
| wasmtime_f64_nearest | Implementation of f64.nearest + |
| wasmtime_imported_memory32_grow⚠ | Implementation of memory.grow for imported 32-bit memories. + |
| wasmtime_imported_memory32_size⚠ | Implementation of memory.size for imported 32-bit memories. + |
| wasmtime_memory32_grow⚠ | Implementation of memory.grow for locally-defined 32-bit memories. + |
| wasmtime_memory32_size⚠ | Implementation of memory.size for locally-defined 32-bit memories. + |
Redirecting to ../../wasmtime_runtime/struct.Mmap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/sidebar-items.js b/api/wasmtime_runtime/sidebar-items.js new file mode 100644 index 000000000000..515d6be4c231 --- /dev/null +++ b/api/wasmtime_runtime/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"constant":[["VERSION","Version number of this crate."]],"enum":[["Export","The value of an export passed from one instance to another."],["InstantiationError","An error while instantiating a module."],["Trap","Stores trace message with backtrace."]],"fn":[["catch_traps","Catches any wasm traps that happen within the execution of `closure`, returning them as a `Result`."],["raise_user_trap","Raises a user-defined trap immediately."],["resume_panic","Carries a Rust panic across wasm code and resumes the panic on the other side."],["wasmtime_call_trampoline","Call the wasm function pointed to by `callee`."]],"mod":[["libcalls","Runtime library calls. Note that wasm compilers may sometimes perform these inline rather than calling them, particularly when CPUs have special instructions which compute them directly."]],"struct":[["GdbJitImageRegistration","Registeration for JIT image"],["Imports","Resolved import pointers."],["InstanceHandle","A handle holding an `Instance` of a WebAssembly module."],["LinkError","An link error while instantiating a module."],["Mmap","A simple struct consisting of a page-aligned pointer to page-aligned and initially-zeroed memory and a length."],["SignatureRegistry","WebAssembly requires that the caller and callee signatures in an indirect call must match. To implement this efficiently, keep a registry of all signatures, shared by all instances, so that call sites can just do an index comparison."],["TrapDescription","Description of a trap."],["TrapRegistration","RAII structure returned from `TrapRegistry::register_trap` to unregister trap information on drop."],["TrapRegistry","The registry maintains descriptions of traps in currently allocated functions."],["VMCallerCheckedAnyfunc","The VM caller-checked \"anyfunc\" record, for caller-side signature checking. It consists of the actual function pointer and a signature id to be checked by the caller."],["VMContext","The VM \"context\", which is pointed to by the `vmctx` arg in Cranelift. This has information about globals, memories, tables, and other runtime state associated with the current instance."],["VMFunctionBody","A placeholder byte-sized type which is just used to provide some amount of type safety when dealing with pointers to JIT-compiled function bodies. Note that it's deliberately not Copy, as we shouldn't be carelessly copying function body bytes around."],["VMFunctionImport","An imported function."],["VMGlobalDefinition","The storage for a WebAssembly global defined within the instance."],["VMGlobalImport","The fields compiled code needs to access to utilize a WebAssembly global variable imported from another instance."],["VMInvokeArgument","The storage for a WebAssembly invocation argument"],["VMMemoryDefinition","The fields compiled code needs to access to utilize a WebAssembly linear memory defined within the instance, namely the start address and the size in bytes."],["VMMemoryImport","The fields compiled code needs to access to utilize a WebAssembly linear memory imported from another instance."],["VMSharedSignatureIndex","An index into the shared signature registry, usable for checking signatures at indirect calls."],["VMTableDefinition","The fields compiled code needs to access to utilize a WebAssembly table defined within the instance."],["VMTableImport","The fields compiled code needs to access to utilize a WebAssembly table imported from another instance."]]}); \ No newline at end of file diff --git a/api/wasmtime_runtime/sig_registry/struct.SignatureRegistry.html b/api/wasmtime_runtime/sig_registry/struct.SignatureRegistry.html new file mode 100644 index 000000000000..3b75c16bee9f --- /dev/null +++ b/api/wasmtime_runtime/sig_registry/struct.SignatureRegistry.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.SignatureRegistry.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/struct.GdbJitImageRegistration.html b/api/wasmtime_runtime/struct.GdbJitImageRegistration.html new file mode 100644 index 000000000000..496dd44fe1ab --- /dev/null +++ b/api/wasmtime_runtime/struct.GdbJitImageRegistration.html @@ -0,0 +1,15 @@ +Registeration for JIT image
+impl GdbJitImageRegistration[src]pub fn register(file: Vec<u8>) -> Self[src]Registers JIT image using __jit_debug_register_code
+pub fn file(&self) -> &[u8][src]JIT image used in registration
+impl Drop for GdbJitImageRegistration[src]impl RefUnwindSafe for GdbJitImageRegistrationimpl !Send for GdbJitImageRegistrationimpl !Sync for GdbJitImageRegistrationimpl Unpin for GdbJitImageRegistrationimpl UnwindSafe for GdbJitImageRegistrationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Resolved import pointers.
+dependencies: HashSet<InstanceHandle>The set of instances that the imports depend on.
+functions: BoxedSlice<FuncIndex, VMFunctionImport>Resolved addresses for imported functions.
+tables: BoxedSlice<TableIndex, VMTableImport>Resolved addresses for imported tables.
+memories: BoxedSlice<MemoryIndex, VMMemoryImport>Resolved addresses for imported memories.
+globals: BoxedSlice<GlobalIndex, VMGlobalImport>Resolved addresses for imported globals.
+impl Imports[src]pub fn new(
dependencies: HashSet<InstanceHandle>,
function_imports: PrimaryMap<FuncIndex, VMFunctionImport>,
table_imports: PrimaryMap<TableIndex, VMTableImport>,
memory_imports: PrimaryMap<MemoryIndex, VMMemoryImport>,
global_imports: PrimaryMap<GlobalIndex, VMGlobalImport>
) -> Self[src]Construct a new Imports instance.
pub fn none() -> Self[src]Construct a new Imports instance with no imports.
impl !RefUnwindSafe for Importsimpl !Send for Importsimpl !Sync for Importsimpl Unpin for Importsimpl !UnwindSafe for Importsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A handle holding an Instance of a WebAssembly module.
impl InstanceHandle[src]pub fn set_signal_handler<H>(&mut self, handler: H) where
H: 'static + Fn(c_int, *const siginfo_t, *const c_void) -> bool, [src]Set a custom signal handler
+impl InstanceHandle[src]pub unsafe fn new(
module: Arc<Module>,
trap_registration: TrapRegistration,
finished_functions: BoxedSlice<DefinedFuncIndex, *mut [VMFunctionBody]>,
imports: Imports,
data_initializers: &[DataInitializer],
vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
dbg_jit_registration: Option<Rc<GdbJitImageRegistration>>,
host_state: Box<dyn Any>
) -> Result<Self, InstantiationError>[src]Create a new InstanceHandle pointing at a new Instance.
This method is not necessarily inherently unsafe to call, but in general
+the APIs of an Instance are quite unsafe and have not been really
+audited for safety that much. As a result the unsafety here on this
+method is a low-overhead way of saying "this is an extremely unsafe type
+to work with".
Extreme care must be taken when working with InstanceHandle and it's
+recommended to have relatively intimate knowledge of how it works
+internally if you'd like to do so. If possible it's recommended to use
+the wasmtime crate API rather than this type since that is vetted for
+safety.
pub unsafe fn from_vmctx(vmctx: *mut VMContext) -> Self[src]Create a new InstanceHandle pointing at the instance
+pointed to by the given VMContext pointer.
This is unsafe because it doesn't work on just any VMContext, it must
+be a VMContext allocated as part of an Instance.
pub fn vmctx(&self) -> &VMContext[src]Return a reference to the vmctx used by compiled wasm code.
+pub fn vmctx_ptr(&self) -> *mut VMContext[src]Return a raw pointer to the vmctx used by compiled wasm code.
+pub fn module(&self) -> &Arc<Module>[src]Return a reference-counting pointer to a module.
+pub fn module_ref(&self) -> &Module[src]Return a reference to a module.
+pub fn lookup(&self, field: &str) -> Option<Export>[src]Lookup an export with the given name.
+pub fn lookup_by_declaration(&self, export: &Export) -> Export[src]Lookup an export with the given export declaration.
+pub fn exports(&self) -> Iter<String, Export>[src]Return an iterator over the exports of this instance.
+Specifically, it provides access to the key-value pairs, where the keys
+are export names, and the values are export declarations which can be
+resolved lookup_by_declaration.
pub fn host_state(&self) -> &dyn Any[src]Return a reference to the custom state attached to this instance.
+pub fn memory_index(&self, memory: &VMMemoryDefinition) -> DefinedMemoryIndex[src]Return the memory index for the given VMMemoryDefinition in this instance.
pub fn memory_grow(
&self,
memory_index: DefinedMemoryIndex,
delta: u32
) -> Option<u32>[src]Grow memory in this instance by the specified amount of pages.
+Returns None if memory can't be grown by the specified amount
+of pages.
pub fn table_index(&self, table: &VMTableDefinition) -> DefinedTableIndex[src]Return the table index for the given VMTableDefinition in this instance.
pub fn table_grow(
&self,
table_index: DefinedTableIndex,
delta: u32
) -> Option<u32>[src]Grow table in this instance by the specified amount of pages.
+Returns None if memory can't be grown by the specified amount
+of pages.
pub fn table_get(
&self,
table_index: DefinedTableIndex,
index: u32
) -> Option<VMCallerCheckedAnyfunc>[src]Get table element reference.
+Returns None if index is out of bounds.
pub fn table_set(
&self,
table_index: DefinedTableIndex,
index: u32,
val: VMCallerCheckedAnyfunc
) -> Result<(), ()>[src]Set table element reference.
+Returns an error if the index is out of bounds
+impl Clone for InstanceHandle[src]fn clone(&self) -> Self[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Drop for InstanceHandle[src]impl Eq for InstanceHandle[src]impl Hash for InstanceHandle[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<InstanceHandle> for InstanceHandle[src]fn eq(&self, other: &InstanceHandle) -> bool[src]fn ne(&self, other: &InstanceHandle) -> bool[src]impl StructuralEq for InstanceHandle[src]impl StructuralPartialEq for InstanceHandle[src]impl !RefUnwindSafe for InstanceHandleimpl !Send for InstanceHandleimpl !Sync for InstanceHandleimpl Unpin for InstanceHandleimpl !UnwindSafe for InstanceHandleimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An link error while instantiating a module.
+impl Debug for LinkError[src]impl Display for LinkError[src]impl Error for LinkError[src]fn source(&self) -> Option<&(dyn Error + 'static)>1.30.0[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<LinkError> for InstantiationError[src]impl RefUnwindSafe for LinkErrorimpl Send for LinkErrorimpl Sync for LinkErrorimpl Unpin for LinkErrorimpl UnwindSafe for LinkErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A simple struct consisting of a page-aligned pointer to page-aligned +and initially-zeroed memory and a length.
+impl Mmap[src]pub fn new() -> Self[src]Construct a new empty instance of Mmap.
pub fn with_at_least(size: usize) -> Result<Self, String>[src]Create a new Mmap pointing to at least size bytes of page-aligned accessible memory.
pub fn accessible_reserved(
accessible_size: usize,
mapping_size: usize
) -> Result<Self, String>[src]Create a new Mmap pointing to accessible_size bytes of page-aligned accessible memory,
+within a reserved mapping of mapping_size bytes. accessible_size and mapping_size
+must be native page-size multiples.
pub fn make_accessible(
&mut self,
start: usize,
len: usize
) -> Result<(), String>[src]Make the memory starting at start and extending for len bytes accessible.
+start and len must be native page-size multiples and describe a range within
+self's reserved memory.
pub fn as_slice(&self) -> &[u8][src]Return the allocated memory as a slice of u8.
+pub fn as_mut_slice(&mut self) -> &mut [u8][src]Return the allocated memory as a mutable slice of u8.
+pub fn as_ptr(&self) -> *const u8[src]Return the allocated memory as a pointer to u8.
+pub fn as_mut_ptr(&mut self) -> *mut u8[src]Return the allocated memory as a mutable pointer to u8.
+pub fn len(&self) -> usize[src]Return the length of the allocated memory.
+pub fn is_empty(&self) -> bool[src]Return whether any memory has been allocated.
+impl RefUnwindSafe for Mmapimpl Send for Mmapimpl Sync for Mmapimpl Unpin for Mmapimpl UnwindSafe for Mmapimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]WebAssembly requires that the caller and callee signatures in an indirect +call must match. To implement this efficiently, keep a registry of all +signatures, shared by all instances, so that call sites can just do an +index comparison.
+impl SignatureRegistry[src]pub fn new() -> Self[src]Create a new SignatureRegistry.
pub fn register(&self, sig: &Signature) -> VMSharedSignatureIndex[src]Register a signature and return its unique index.
+pub fn lookup(&self, idx: VMSharedSignatureIndex) -> Option<Signature>[src]Looks up a shared signature index within this registry.
+Note that for this operation to be semantically correct the idx must
+have previously come from a call to register of this same object.
impl RefUnwindSafe for SignatureRegistryimpl Send for SignatureRegistryimpl Sync for SignatureRegistryimpl Unpin for SignatureRegistryimpl UnwindSafe for SignatureRegistryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Description of a trap.
+source_loc: SourceLocLocation of the trap in source binary module.
+trap_code: TrapCodeCode of the trap.
+impl Clone for TrapDescription[src]fn clone(&self) -> TrapDescription[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for TrapDescription[src]impl Debug for TrapDescription[src]impl Display for TrapDescription[src]impl PartialEq<TrapDescription> for TrapDescription[src]fn eq(&self, other: &TrapDescription) -> bool[src]fn ne(&self, other: &TrapDescription) -> bool[src]impl StructuralPartialEq for TrapDescription[src]impl RefUnwindSafe for TrapDescriptionimpl Send for TrapDescriptionimpl Sync for TrapDescriptionimpl Unpin for TrapDescriptionimpl UnwindSafe for TrapDescriptionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]RAII structure returned from TrapRegistry::register_trap to unregister
+trap information on drop.
impl TrapRegistration[src]pub fn get_trap(&self, address: usize) -> Option<TrapDescription>[src]Gets a trap description at given address.
+impl Clone for TrapRegistration[src]fn clone(&self) -> TrapRegistration[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Drop for TrapRegistration[src]impl RefUnwindSafe for TrapRegistrationimpl Send for TrapRegistrationimpl Sync for TrapRegistrationimpl Unpin for TrapRegistrationimpl UnwindSafe for TrapRegistrationimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The registry maintains descriptions of traps in currently allocated functions.
+impl TrapRegistry[src]pub fn register_traps(
&self,
list: impl IntoIterator<Item = (usize, SourceLoc, TrapCode)>
) -> TrapRegistration[src]Registers a list of traps.
+Returns a RAII guard that deregisters all traps when dropped.
+impl Default for TrapRegistry[src]fn default() -> TrapRegistry[src]impl RefUnwindSafe for TrapRegistryimpl Send for TrapRegistryimpl Sync for TrapRegistryimpl Unpin for TrapRegistryimpl UnwindSafe for TrapRegistryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The VM caller-checked "anyfunc" record, for caller-side signature checking. +It consists of the actual function pointer and a signature id to be checked +by the caller.
+func_ptr: *const VMFunctionBodyFunction body.
+type_index: VMSharedSignatureIndexFunction signature id.
+vmctx: *mut VMContextFunction VMContext.
impl Clone for VMCallerCheckedAnyfunc[src]fn clone(&self) -> VMCallerCheckedAnyfunc[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for VMCallerCheckedAnyfunc[src]impl Default for VMCallerCheckedAnyfunc[src]impl RefUnwindSafe for VMCallerCheckedAnyfuncimpl !Send for VMCallerCheckedAnyfuncimpl !Sync for VMCallerCheckedAnyfuncimpl Unpin for VMCallerCheckedAnyfuncimpl UnwindSafe for VMCallerCheckedAnyfuncimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The VM "context", which is pointed to by the vmctx arg in Cranelift.
+This has information about globals, memories, tables, and other runtime
+state associated with the current instance.
The struct here is empty, as the sizes of these fields are dynamic, and +we can't describe them in Rust's type system. Sufficient memory is +allocated at runtime.
+TODO: We could move the globals into the vmctx allocation too.
impl VMContext[src]pub unsafe fn host_state(&self) -> &dyn Any[src]Return a reference to the host state associated with this Instance.
This is unsafe because it doesn't work on just any VMContext, it must
+be a VMContext allocated as part of an Instance.
impl RefUnwindSafe for VMContextimpl Send for VMContextimpl Sync for VMContextimpl Unpin for VMContextimpl UnwindSafe for VMContextimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A placeholder byte-sized type which is just used to provide some amount of type +safety when dealing with pointers to JIT-compiled function bodies. Note that it's +deliberately not Copy, as we shouldn't be carelessly copying function body bytes +around.
+impl RefUnwindSafe for VMFunctionBodyimpl Send for VMFunctionBodyimpl Sync for VMFunctionBodyimpl Unpin for VMFunctionBodyimpl UnwindSafe for VMFunctionBodyimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An imported function.
+body: *const VMFunctionBodyA pointer to the imported function body.
+vmctx: *mut VMContextA pointer to the VMContext that owns the function.
impl Clone for VMFunctionImport[src]fn clone(&self) -> VMFunctionImport[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMFunctionImport[src]impl Debug for VMFunctionImport[src]impl RefUnwindSafe for VMFunctionImportimpl !Send for VMFunctionImportimpl !Sync for VMFunctionImportimpl Unpin for VMFunctionImportimpl UnwindSafe for VMFunctionImportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The storage for a WebAssembly global defined within the instance.
+TODO: Pack the globals more densely, rather than using the same size +for every type.
+impl VMGlobalDefinition[src]pub fn new() -> Self[src]Construct a VMGlobalDefinition.
pub unsafe fn as_i32(&self) -> &i32[src]Return a reference to the value as an i32.
+pub unsafe fn as_i32_mut(&mut self) -> &mut i32[src]Return a mutable reference to the value as an i32.
+pub unsafe fn as_u32(&self) -> &u32[src]Return a reference to the value as a u32.
+pub unsafe fn as_u32_mut(&mut self) -> &mut u32[src]Return a mutable reference to the value as an u32.
+pub unsafe fn as_i64(&self) -> &i64[src]Return a reference to the value as an i64.
+pub unsafe fn as_i64_mut(&mut self) -> &mut i64[src]Return a mutable reference to the value as an i64.
+pub unsafe fn as_u64(&self) -> &u64[src]Return a reference to the value as an u64.
+pub unsafe fn as_u64_mut(&mut self) -> &mut u64[src]Return a mutable reference to the value as an u64.
+pub unsafe fn as_f32(&self) -> &f32[src]Return a reference to the value as an f32.
+pub unsafe fn as_f32_mut(&mut self) -> &mut f32[src]Return a mutable reference to the value as an f32.
+pub unsafe fn as_f32_bits(&self) -> &u32[src]Return a reference to the value as f32 bits.
+pub unsafe fn as_f32_bits_mut(&mut self) -> &mut u32[src]Return a mutable reference to the value as f32 bits.
+pub unsafe fn as_f64(&self) -> &f64[src]Return a reference to the value as an f64.
+pub unsafe fn as_f64_mut(&mut self) -> &mut f64[src]Return a mutable reference to the value as an f64.
+pub unsafe fn as_f64_bits(&self) -> &u64[src]Return a reference to the value as f64 bits.
+pub unsafe fn as_f64_bits_mut(&mut self) -> &mut u64[src]Return a mutable reference to the value as f64 bits.
+pub unsafe fn as_u128(&self) -> &u128[src]Return a reference to the value as an u128.
+pub unsafe fn as_u128_mut(&mut self) -> &mut u128[src]Return a mutable reference to the value as an u128.
+pub unsafe fn as_u128_bits(&self) -> &[u8; 16][src]Return a reference to the value as u128 bits.
+pub unsafe fn as_u128_bits_mut(&mut self) -> &mut [u8; 16][src]Return a mutable reference to the value as u128 bits.
+impl Clone for VMGlobalDefinition[src]fn clone(&self) -> VMGlobalDefinition[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMGlobalDefinition[src]impl Debug for VMGlobalDefinition[src]impl RefUnwindSafe for VMGlobalDefinitionimpl Send for VMGlobalDefinitionimpl Sync for VMGlobalDefinitionimpl Unpin for VMGlobalDefinitionimpl UnwindSafe for VMGlobalDefinitionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The fields compiled code needs to access to utilize a WebAssembly global +variable imported from another instance.
+from: *mut VMGlobalDefinitionA pointer to the imported global variable description.
+impl Clone for VMGlobalImport[src]fn clone(&self) -> VMGlobalImport[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMGlobalImport[src]impl Debug for VMGlobalImport[src]impl RefUnwindSafe for VMGlobalImportimpl !Send for VMGlobalImportimpl !Sync for VMGlobalImportimpl Unpin for VMGlobalImportimpl UnwindSafe for VMGlobalImportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The storage for a WebAssembly invocation argument
+TODO: These could be packed more densely, rather than using the same size for every type.
+impl VMInvokeArgument[src]impl Clone for VMInvokeArgument[src]fn clone(&self) -> VMInvokeArgument[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMInvokeArgument[src]impl Debug for VMInvokeArgument[src]impl RefUnwindSafe for VMInvokeArgumentimpl Send for VMInvokeArgumentimpl Sync for VMInvokeArgumentimpl Unpin for VMInvokeArgumentimpl UnwindSafe for VMInvokeArgumentimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The fields compiled code needs to access to utilize a WebAssembly linear +memory defined within the instance, namely the start address and the +size in bytes.
+base: *mut u8The start address.
+current_length: usizeThe current logical size of this linear memory in bytes.
+impl Clone for VMMemoryDefinition[src]fn clone(&self) -> VMMemoryDefinition[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMMemoryDefinition[src]impl Debug for VMMemoryDefinition[src]impl RefUnwindSafe for VMMemoryDefinitionimpl !Send for VMMemoryDefinitionimpl !Sync for VMMemoryDefinitionimpl Unpin for VMMemoryDefinitionimpl UnwindSafe for VMMemoryDefinitionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The fields compiled code needs to access to utilize a WebAssembly linear +memory imported from another instance.
+from: *mut VMMemoryDefinitionA pointer to the imported memory description.
+vmctx: *mut VMContextA pointer to the VMContext that owns the memory description.
impl Clone for VMMemoryImport[src]fn clone(&self) -> VMMemoryImport[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMMemoryImport[src]impl Debug for VMMemoryImport[src]impl RefUnwindSafe for VMMemoryImportimpl !Send for VMMemoryImportimpl !Sync for VMMemoryImportimpl Unpin for VMMemoryImportimpl UnwindSafe for VMMemoryImportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An index into the shared signature registry, usable for checking signatures +at indirect calls.
+impl VMSharedSignatureIndex[src]impl Clone for VMSharedSignatureIndex[src]fn clone(&self) -> VMSharedSignatureIndex[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMSharedSignatureIndex[src]impl Debug for VMSharedSignatureIndex[src]impl Default for VMSharedSignatureIndex[src]impl Eq for VMSharedSignatureIndex[src]impl Hash for VMSharedSignatureIndex[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<VMSharedSignatureIndex> for VMSharedSignatureIndex[src]fn eq(&self, other: &VMSharedSignatureIndex) -> bool[src]fn ne(&self, other: &VMSharedSignatureIndex) -> bool[src]impl StructuralEq for VMSharedSignatureIndex[src]impl StructuralPartialEq for VMSharedSignatureIndex[src]impl RefUnwindSafe for VMSharedSignatureIndeximpl Send for VMSharedSignatureIndeximpl Sync for VMSharedSignatureIndeximpl Unpin for VMSharedSignatureIndeximpl UnwindSafe for VMSharedSignatureIndeximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The fields compiled code needs to access to utilize a WebAssembly table +defined within the instance.
+base: *mut u8Pointer to the table data.
+current_elements: u32The current number of elements in the table.
+impl Clone for VMTableDefinition[src]fn clone(&self) -> VMTableDefinition[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMTableDefinition[src]impl Debug for VMTableDefinition[src]impl RefUnwindSafe for VMTableDefinitionimpl !Send for VMTableDefinitionimpl !Sync for VMTableDefinitionimpl Unpin for VMTableDefinitionimpl UnwindSafe for VMTableDefinitionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]The fields compiled code needs to access to utilize a WebAssembly table +imported from another instance.
+from: *mut VMTableDefinitionA pointer to the imported table description.
+vmctx: *mut VMContextA pointer to the VMContext that owns the table description.
impl Clone for VMTableImport[src]fn clone(&self) -> VMTableImport[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for VMTableImport[src]impl Debug for VMTableImport[src]impl RefUnwindSafe for VMTableImportimpl !Send for VMTableImportimpl !Sync for VMTableImportimpl Unpin for VMTableImportimpl UnwindSafe for VMTableImportimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime_runtime/struct.TrapDescription.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/trap_registry/struct.TrapRegistration.html b/api/wasmtime_runtime/trap_registry/struct.TrapRegistration.html new file mode 100644 index 000000000000..43819e60eddc --- /dev/null +++ b/api/wasmtime_runtime/trap_registry/struct.TrapRegistration.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.TrapRegistration.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/trap_registry/struct.TrapRegistry.html b/api/wasmtime_runtime/trap_registry/struct.TrapRegistry.html new file mode 100644 index 000000000000..9bae1af33b0e --- /dev/null +++ b/api/wasmtime_runtime/trap_registry/struct.TrapRegistry.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.TrapRegistry.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/traphandlers/enum.Trap.html b/api/wasmtime_runtime/traphandlers/enum.Trap.html new file mode 100644 index 000000000000..cf961fc294f2 --- /dev/null +++ b/api/wasmtime_runtime/traphandlers/enum.Trap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/enum.Trap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/traphandlers/fn.catch_traps.html b/api/wasmtime_runtime/traphandlers/fn.catch_traps.html new file mode 100644 index 000000000000..207487906d7e --- /dev/null +++ b/api/wasmtime_runtime/traphandlers/fn.catch_traps.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/fn.catch_traps.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/traphandlers/fn.raise_user_trap.html b/api/wasmtime_runtime/traphandlers/fn.raise_user_trap.html new file mode 100644 index 000000000000..fb8b8a5ac651 --- /dev/null +++ b/api/wasmtime_runtime/traphandlers/fn.raise_user_trap.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/fn.raise_user_trap.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/traphandlers/fn.resume_panic.html b/api/wasmtime_runtime/traphandlers/fn.resume_panic.html new file mode 100644 index 000000000000..847b2359d497 --- /dev/null +++ b/api/wasmtime_runtime/traphandlers/fn.resume_panic.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/fn.resume_panic.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/traphandlers/fn.wasmtime_call_trampoline.html b/api/wasmtime_runtime/traphandlers/fn.wasmtime_call_trampoline.html new file mode 100644 index 000000000000..4b11846ab2c1 --- /dev/null +++ b/api/wasmtime_runtime/traphandlers/fn.wasmtime_call_trampoline.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/fn.wasmtime_call_trampoline.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMCallerCheckedAnyfunc.html b/api/wasmtime_runtime/vmcontext/struct.VMCallerCheckedAnyfunc.html new file mode 100644 index 000000000000..dd5b6e8f0718 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMCallerCheckedAnyfunc.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMCallerCheckedAnyfunc.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMContext.html b/api/wasmtime_runtime/vmcontext/struct.VMContext.html new file mode 100644 index 000000000000..d4af01fb127a --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMContext.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMContext.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMFunctionBody.html b/api/wasmtime_runtime/vmcontext/struct.VMFunctionBody.html new file mode 100644 index 000000000000..abc7f9e72274 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMFunctionBody.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMFunctionBody.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMFunctionImport.html b/api/wasmtime_runtime/vmcontext/struct.VMFunctionImport.html new file mode 100644 index 000000000000..0f74b948a0ae --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMFunctionImport.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMFunctionImport.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMGlobalDefinition.html b/api/wasmtime_runtime/vmcontext/struct.VMGlobalDefinition.html new file mode 100644 index 000000000000..8bf61ca5fb56 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMGlobalDefinition.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMGlobalDefinition.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMGlobalImport.html b/api/wasmtime_runtime/vmcontext/struct.VMGlobalImport.html new file mode 100644 index 000000000000..3588f82125db --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMGlobalImport.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMGlobalImport.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMInvokeArgument.html b/api/wasmtime_runtime/vmcontext/struct.VMInvokeArgument.html new file mode 100644 index 000000000000..08307869a105 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMInvokeArgument.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMInvokeArgument.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMMemoryDefinition.html b/api/wasmtime_runtime/vmcontext/struct.VMMemoryDefinition.html new file mode 100644 index 000000000000..5763ef295c07 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMMemoryDefinition.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMMemoryDefinition.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMMemoryImport.html b/api/wasmtime_runtime/vmcontext/struct.VMMemoryImport.html new file mode 100644 index 000000000000..7bf44a1ef0f3 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMMemoryImport.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMMemoryImport.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMSharedSignatureIndex.html b/api/wasmtime_runtime/vmcontext/struct.VMSharedSignatureIndex.html new file mode 100644 index 000000000000..ec0506191025 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMSharedSignatureIndex.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMSharedSignatureIndex.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMTableDefinition.html b/api/wasmtime_runtime/vmcontext/struct.VMTableDefinition.html new file mode 100644 index 000000000000..4aa8bdd2edd0 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMTableDefinition.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMTableDefinition.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_runtime/vmcontext/struct.VMTableImport.html b/api/wasmtime_runtime/vmcontext/struct.VMTableImport.html new file mode 100644 index 000000000000..02184351c479 --- /dev/null +++ b/api/wasmtime_runtime/vmcontext/struct.VMTableImport.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../wasmtime_runtime/struct.VMTableImport.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_rust/all.html b/api/wasmtime_rust/all.html new file mode 100644 index 000000000000..1679be9a603a --- /dev/null +++ b/api/wasmtime_rust/all.html @@ -0,0 +1,3 @@ +#[wasmtime]
| wasmtime |
#[wasmtime]
| wasmtime |
pub fn is_wasi_module(name: &str) -> bool
| old |
| Wasi | An instantiated instance of the wasi exports. + |
| WasiCtx | |
| WasiCtxBuilder | A builder allowing customizable construction of |
| is_wasi_module |
| snapshot_0 |
pub fn is_wasi_module(name: &str) -> bool
| Wasi | An instantiated instance of the wasi exports. + |
| is_wasi_module |
An instantiated instance of the wasi exports.
+This represents a wasi module which can be used to instantiate other
+wasm modules. This structure exports all that various fields of the
+wasi instance as fields which can be used to implement your own
+instantiation logic, if necessary. Additionally Wasi::get_export
+can be used to do name-based resolution.
args_get: Funcargs_sizes_get: Funcenviron_get: Funcenviron_sizes_get: Funcclock_res_get: Funcclock_time_get: Funcfd_advise: Funcfd_allocate: Funcfd_close: Funcfd_datasync: Funcfd_fdstat_get: Funcfd_fdstat_set_flags: Funcfd_fdstat_set_rights: Funcfd_filestat_get: Funcfd_filestat_set_size: Funcfd_filestat_set_times: Funcfd_pread: Funcfd_prestat_get: Funcfd_prestat_dir_name: Funcfd_pwrite: Funcfd_read: Funcfd_readdir: Funcfd_renumber: Funcfd_seek: Funcfd_sync: Funcfd_tell: Funcfd_write: Funcpath_create_directory: Funcpath_filestat_get: Funcpath_filestat_set_times: Funcpath_link: Funcpath_open: Funcpath_readlink: Funcpath_remove_directory: Funcpath_rename: Funcpath_symlink: Funcpath_unlink_file: Funcpoll_oneoff: Funcproc_exit: Funcproc_raise: Funcsched_yield: Funcrandom_get: Funcsock_recv: Funcsock_send: Funcsock_shutdown: Funcimpl Wasi[src]pub fn new(store: &Store, cx: WasiCtx) -> Wasi[src]Creates a new Wasi instance.
External values are allocated into the store provided and
+configuration of the wasi instance itself should be all
+contained in the cx parameter.
pub fn get_export(&self, name: &str) -> Option<&Func>[src]Looks up a field called name in this structure, returning it
+if found.
This is often useful when instantiating a wasmtime instance
+where name resolution often happens with strings.
impl !RefUnwindSafe for Wasiimpl !Send for Wasiimpl !Sync for Wasiimpl Unpin for Wasiimpl !UnwindSafe for Wasiimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]An instantiated instance of the wasi exports.
+This represents a wasi module which can be used to instantiate other
+wasm modules. This structure exports all that various fields of the
+wasi instance as fields which can be used to implement your own
+instantiation logic, if necessary. Additionally Wasi::get_export
+can be used to do name-based resolution.
args_get: Funcargs_sizes_get: Funcenviron_get: Funcenviron_sizes_get: Funcclock_res_get: Funcclock_time_get: Funcfd_advise: Funcfd_allocate: Funcfd_close: Funcfd_datasync: Funcfd_fdstat_get: Funcfd_fdstat_set_flags: Funcfd_fdstat_set_rights: Funcfd_filestat_get: Funcfd_filestat_set_size: Funcfd_filestat_set_times: Funcfd_pread: Funcfd_prestat_get: Funcfd_prestat_dir_name: Funcfd_pwrite: Funcfd_read: Funcfd_readdir: Funcfd_renumber: Funcfd_seek: Funcfd_sync: Funcfd_tell: Funcfd_write: Funcpath_create_directory: Funcpath_filestat_get: Funcpath_filestat_set_times: Funcpath_link: Funcpath_open: Funcpath_readlink: Funcpath_remove_directory: Funcpath_rename: Funcpath_symlink: Funcpath_unlink_file: Funcpoll_oneoff: Funcproc_exit: Funcproc_raise: Funcsched_yield: Funcrandom_get: Funcsock_recv: Funcsock_send: Funcsock_shutdown: Funcimpl Wasi[src]pub fn new(store: &Store, cx: WasiCtx) -> Wasi[src]Creates a new Wasi instance.
External values are allocated into the store provided and
+configuration of the wasi instance itself should be all
+contained in the cx parameter.
pub fn get_export(&self, name: &str) -> Option<&Func>[src]Looks up a field called name in this structure, returning it
+if found.
This is often useful when instantiating a wasmtime instance
+where name resolution often happens with strings.
impl !RefUnwindSafe for Wasiimpl !Send for Wasiimpl !Sync for Wasiimpl Unpin for Wasiimpl !UnwindSafe for Wasiimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl WasiCtx[src]pub fn new<S>(args: impl IntoIterator<Item = S>) -> Result<WasiCtx, Error> where
S: AsRef<[u8]>, [src]Make a new WasiCtx with some default settings.
File descriptors 0, 1, and 2 inherit stdin, stdout, and stderr from the host process.
+Environment variables are inherited from the host process.
+To override these behaviors, use WasiCtxBuilder.
impl RefUnwindSafe for WasiCtximpl Send for WasiCtximpl Sync for WasiCtximpl Unpin for WasiCtximpl UnwindSafe for WasiCtximpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]A builder allowing customizable construction of WasiCtx instances.
impl WasiCtxBuilder[src]pub fn new() -> WasiCtxBuilder[src]Builder for a new WasiCtx.
pub fn args<S>(self, args: impl IntoIterator<Item = S>) -> WasiCtxBuilder where
S: AsRef<[u8]>, [src]Add arguments to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn arg<S>(self, arg: S) -> WasiCtxBuilder where
S: AsRef<[u8]>, [src]Add an argument to the command-line arguments list.
+Arguments must be valid UTF-8 with no NUL bytes, or else WasiCtxBuilder::build() will fail
+with Error::EILSEQ.
pub fn inherit_args(self) -> WasiCtxBuilder[src]Inherit the command-line arguments from the host process.
+If any arguments from the host process contain invalid UTF-8, WasiCtxBuilder::build() will
+fail with Error::EILSEQ.
pub fn inherit_stdio(self) -> WasiCtxBuilder[src]Inherit the stdin, stdout, and stderr streams from the host process.
+pub fn inherit_env(self) -> WasiCtxBuilder[src]Inherit the environment variables from the host process.
+If any environment variables from the host process contain invalid Unicode (UTF-16 for
+Windows, UTF-8 for other platforms), WasiCtxBuilder::build() will fail with
+Error::EILSEQ.
pub fn env<S>(self, k: S, v: S) -> WasiCtxBuilder where
S: AsRef<[u8]>, [src]Add an entry to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn envs<S, T>(self, envs: impl IntoIterator<Item = T>) -> WasiCtxBuilder where
S: AsRef<[u8]>,
T: Borrow<(S, S)>, [src]Add entries to the environment.
+Environment variable keys and values must be valid UTF-8 with no NUL bytes, or else
+WasiCtxBuilder::build() will fail with Error::EILSEQ.
pub fn stdin(self, file: File) -> WasiCtxBuilder[src]Provide a File to use as stdin
+pub fn stdout(self, file: File) -> WasiCtxBuilder[src]Provide a File to use as stdout
+pub fn stderr(self, file: File) -> WasiCtxBuilder[src]Provide a File to use as stderr
+pub fn preopened_dir<P>(self, dir: File, guest_path: P) -> WasiCtxBuilder where
P: AsRef<Path>, [src]Add a preopened directory.
+pub fn build(self) -> Result<WasiCtx, Error>[src]Build a WasiCtx, consuming this WasiCtxBuilder.
If any of the arguments or environment variables in this builder cannot be converted into
+CStrings, either due to NUL bytes or Unicode conversions, this returns Error::EILSEQ.
impl RefUnwindSafe for WasiCtxBuilderimpl Send for WasiCtxBuilderimpl Sync for WasiCtxBuilderimpl Unpin for WasiCtxBuilderimpl UnwindSafe for WasiCtxBuilderimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub const VERSION: &str = env!("CARGO_PKG_VERSION");
Version number of this crate.
+pub fn instantiate_spectest(store: &Store) -> HashMap<&'static str, Extern>
Return an instance implementing the "spectest" interface used in the +spec testsuite.
+Implementation of the WAST text format for wasmtime.
+| WastContext | The wast test script language allows modules to be defined and actions +to be performed on them. + |
| VERSION | Version number of this crate. + |
| instantiate_spectest | Return an instance implementing the "spectest" interface used in the +spec testsuite. + |
Redirecting to ../../wasmtime_wast/fn.instantiate_spectest.html...
+ + + \ No newline at end of file diff --git a/api/wasmtime_wast/struct.WastContext.html b/api/wasmtime_wast/struct.WastContext.html new file mode 100644 index 000000000000..d22b5e6e705a --- /dev/null +++ b/api/wasmtime_wast/struct.WastContext.html @@ -0,0 +1,17 @@ +The wast test script language allows modules to be defined and actions +to be performed on them.
+impl WastContext[src]pub fn new(store: Store) -> Self[src]Construct a new instance of WastContext.
pub fn register_spectest(&mut self) -> Result<()>[src]Register "spectest" which is used by the spec testsuite.
+pub fn run_buffer(&mut self, filename: &str, wast: &[u8]) -> Result<()>[src]Run a wast script from a byte buffer.
+pub fn run_file(&mut self, path: &Path) -> Result<()>[src]Run a wast script from a file.
+impl !RefUnwindSafe for WastContextimpl !Send for WastContextimpl !Sync for WastContextimpl Unpin for WastContextimpl !UnwindSafe for WastContextimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../wasmtime_wast/struct.WastContext.html...
+ + + \ No newline at end of file diff --git a/api/wheel.svg b/api/wheel.svg new file mode 100644 index 000000000000..01da3b24c7c4 --- /dev/null +++ b/api/wheel.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/api/wig/all.html b/api/wig/all.html new file mode 100644 index 000000000000..0d1897e02ef5 --- /dev/null +++ b/api/wig/all.html @@ -0,0 +1,3 @@ +| define_hostcalls | |
| define_wasi_struct | A single-use macro in the |
| witx_host_types | |
| witx_wasi32_types | |
| witx_wasi_types |
Redirecting to macro.define_hostcalls.html...
+ + + \ No newline at end of file diff --git a/api/wig/macro.define_hostcalls.html b/api/wig/macro.define_hostcalls.html new file mode 100644 index 000000000000..e879d929d10c --- /dev/null +++ b/api/wig/macro.define_hostcalls.html @@ -0,0 +1 @@ +define_hostcalls!() { /* proc-macro */ }Redirecting to macro.define_wasi_struct.html...
+ + + \ No newline at end of file diff --git a/api/wig/macro.define_wasi_struct.html b/api/wig/macro.define_wasi_struct.html new file mode 100644 index 000000000000..6d9c93de3621 --- /dev/null +++ b/api/wig/macro.define_wasi_struct.html @@ -0,0 +1,2 @@ +define_wasi_struct!() { /* proc-macro */ }A single-use macro in the wasmtime-wasi crate.
Redirecting to macro.witx_host_types.html...
+ + + \ No newline at end of file diff --git a/api/wig/macro.witx_host_types.html b/api/wig/macro.witx_host_types.html new file mode 100644 index 000000000000..c03788ba2317 --- /dev/null +++ b/api/wig/macro.witx_host_types.html @@ -0,0 +1 @@ +witx_host_types!() { /* proc-macro */ }Redirecting to macro.witx_wasi32_types.html...
+ + + \ No newline at end of file diff --git a/api/wig/macro.witx_wasi32_types.html b/api/wig/macro.witx_wasi32_types.html new file mode 100644 index 000000000000..ae65b4774ca6 --- /dev/null +++ b/api/wig/macro.witx_wasi32_types.html @@ -0,0 +1 @@ +witx_wasi32_types!() { /* proc-macro */ }Redirecting to macro.witx_wasi_types.html...
+ + + \ No newline at end of file diff --git a/api/wig/macro.witx_wasi_types.html b/api/wig/macro.witx_wasi_types.html new file mode 100644 index 000000000000..1985e54ebccc --- /dev/null +++ b/api/wig/macro.witx_wasi_types.html @@ -0,0 +1 @@ +witx_wasi_types!() { /* proc-macro */ }impl ClockId[src]impl RefUnwindSafe for ClockIdimpl Send for ClockIdimpl Sync for ClockIdimpl Unpin for ClockIdimpl UnwindSafe for ClockIdimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub fn clock_getres(clock_id: ClockId) -> Result<timespec>
pub fn clock_gettime(clock_id: ClockId) -> Result<timespec>
| ClockId |
| clock_getres | |
| clock_gettime |
impl FileType[src]impl RefUnwindSafe for FileTypeimpl Send for FileTypeimpl Sync for FileTypeimpl Unpin for FileTypeimpl UnwindSafe for FileTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]| Dir | |
| DirIter | |
| Entry | |
| SeekLoc |
| FileType |
| EntryExt |
impl Dir[src]pub fn from<F: IntoRawFd>(fd: F) -> Result<Self>[src]Takes the ownership of the passed-in descriptor-based object,
+and creates a new instance of Dir.
pub fn seek(&mut self, loc: SeekLoc)[src]Set the position of the directory stream, see seekdir(3).
pub fn rewind(&mut self)[src]Reset directory stream, see rewinddir(3).
pub fn tell(&self) -> SeekLoc[src]Get the current position in the directory stream.
+If this location is given to Dir::seek, the entries up to the previously returned
+will be omitted and the iteration will start from the currently pending directory entry.
impl AsRawFd for Dir[src]impl Clone for Dir[src]impl Debug for Dir[src]impl Drop for Dir[src]impl Eq for Dir[src]impl Hash for Dir[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Dir> for Dir[src]impl Send for Dir[src]impl StructuralEq for Dir[src]impl StructuralPartialEq for Dir[src]impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl<T> DirIter<T> where
T: Deref<Target = Dir>, [src]impl<T: Debug + Deref<Target = Dir>> Debug for DirIter<T>[src]impl<T> Iterator for DirIter<T> where
T: Deref<Target = Dir>, [src]type Item = Result<Entry>The type of the elements being iterated over.
+fn next(&mut self) -> Option<Self::Item>[src]fn size_hint(&self) -> (usize, Option<usize>)1.0.0[src]fn count(self) -> usize1.0.0[src]fn last(self) -> Option<Self::Item>1.0.0[src]fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[src]fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>, 1.0.0[src]fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator, 1.0.0[src]fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, 1.0.0[src]fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), 1.21.0[src]fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]fn enumerate(self) -> Enumerate<Self>1.0.0[src]fn peekable(self) -> Peekable<Self>1.0.0[src]fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>, [src]fn skip(self, n: usize) -> Skip<Self>1.0.0[src]fn take(self, n: usize) -> Take<Self>1.0.0[src]fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator, 1.0.0[src]fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator, 1.29.0[src]fn fuse(self) -> Fuse<Self>1.0.0[src]fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), 1.0.0[src]fn by_ref(&mut self) -> &mut Self1.0.0[src]#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
+fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, 1.0.0[src]fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, 1.0.0[src]fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a, [src]fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0[src]fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, 1.27.0[src]fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, 1.0.0[src]fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, 1.0.0[src]fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.0.0[src]fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>, [src]fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, 1.0.0[src]fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, 1.0.0[src]fn max(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]fn min(self) -> Option<Self::Item> where
Self::Item: Ord, 1.0.0[src]fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator, 1.0.0[src]fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, 1.0.0[src]fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, 1.36.0[src]fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, 1.0.0[src]fn cycle(self) -> Cycle<Self> where
Self: Clone, 1.0.0[src]fn sum<S>(self) -> S where
S: Sum<Self::Item>, 1.11.0[src]fn product<P>(self) -> P where
P: Product<Self::Item>, 1.11.0[src]fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, 1.5.0[src]fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]impl<T> RefUnwindSafe for DirIter<T> where
T: RefUnwindSafe, impl<T> Send for DirIter<T> where
T: Send, impl<T> Sync for DirIter<T> where
T: Sync, impl<T> Unpin for DirIter<T> where
T: Unpin, impl<T> UnwindSafe for DirIter<T> where
T: UnwindSafe, impl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<I> IntoIterator for I where
I: Iterator, [src]type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
+type IntoIter = IWhich kind of iterator are we turning this into?
+fn into_iter(self) -> I[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl Entry[src]pub fn file_name(&self) -> &CStr[src]Returns the file name of this directory entry.
+pub fn file_type(&self) -> FileType[src]Returns the type of this directory entry.
+impl Clone for Entry[src]impl Copy for Entry[src]impl Debug for Entry[src]impl EntryExt for Entry[src]impl RefUnwindSafe for Entryimpl Send for Entryimpl Sync for Entryimpl Unpin for Entryimpl UnwindSafe for Entryimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl SeekLoc[src]impl SeekLoc[src]impl RefUnwindSafe for SeekLocimpl Send for SeekLocimpl Sync for SeekLocimpl Unpin for SeekLocimpl UnwindSafe for SeekLocimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl Errno[src]pub fn from_i32(err: i32) -> Self[src]pub fn last() -> Self[src]pub fn from_success_code<T: IsZero>(t: T) -> Result<()>[src]pub fn from_result<T: IsMinusOne>(t: T) -> Result<T>[src]impl Clone for Errno[src]impl Copy for Errno[src]impl Debug for Errno[src]impl Display for Errno[src]impl Eq for Errno[src]impl Error for Errno[src]fn source(&self) -> Option<&(dyn Error + 'static)>1.30.0[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<Errno> for YanixError[src]impl Hash for Errno[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<Errno> for Errno[src]impl StructuralEq for Errno[src]impl StructuralPartialEq for Errno[src]impl RefUnwindSafe for Errnoimpl Send for Errnoimpl Sync for Errnoimpl Unpin for Errnoimpl UnwindSafe for Errnoimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Errno(Errno)NulError(NulError)TryFromIntError(TryFromIntError)impl Debug for YanixError[src]impl Display for YanixError[src]impl Error for YanixError[src]fn source(&self) -> Option<&(dyn Error + 'static)>[src]fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<Errno> for YanixError[src]impl From<NulError> for YanixError[src]impl From<TryFromIntError> for YanixError[src]fn from(source: TryFromIntError) -> Self[src]impl RefUnwindSafe for YanixErrorimpl Send for YanixErrorimpl Sync for YanixErrorimpl Unpin for YanixErrorimpl UnwindSafe for YanixErrorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]Redirecting to ../../yanix/enum.Errno.html...
+ + + \ No newline at end of file diff --git a/api/yanix/fadvise/enum.PosixFadviseAdvice.html b/api/yanix/fadvise/enum.PosixFadviseAdvice.html new file mode 100644 index 000000000000..839ea71e5761 --- /dev/null +++ b/api/yanix/fadvise/enum.PosixFadviseAdvice.html @@ -0,0 +1,27 @@ +impl Clone for PosixFadviseAdvice[src]fn clone(&self) -> PosixFadviseAdvice[src]fn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for PosixFadviseAdvice[src]impl Debug for PosixFadviseAdvice[src]impl RefUnwindSafe for PosixFadviseAdviceimpl Send for PosixFadviseAdviceimpl Sync for PosixFadviseAdviceimpl Unpin for PosixFadviseAdviceimpl UnwindSafe for PosixFadviseAdviceimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub unsafe fn posix_fadvise(
fd: RawFd,
offset: off_t,
len: off_t,
advice: PosixFadviseAdvice
) -> Result<()>
| PosixFadviseAdvice |
| posix_fadvise⚠ |
pub unsafe fn dup_fd(fd: RawFd, close_on_exec: bool) -> Result<RawFd>
pub unsafe fn get_fd_flags(fd: RawFd) -> Result<FdFlag>
pub unsafe fn get_status_flags(fd: RawFd) -> Result<OFlag>
pub unsafe fn set_fd_flags(fd: RawFd, flags: FdFlag) -> Result<()>
pub unsafe fn set_status_flags(fd: RawFd, flags: OFlag) -> Result<()>
| dup_fd⚠ | |
| get_fd_flags⚠ | |
| get_status_flags⚠ | |
| set_fd_flags⚠ | |
| set_status_flags⚠ |
pub unsafe fn fionread(fd: RawFd) -> Result<usize>
fionread() function, equivalent to ioctl(fd, FIONREAD, *bytes).
pub unsafe fn fstat(fd: RawFd) -> Result<stat>
pub unsafe fn fstatat<P: AsRef<OsStr>>(
dirfd: RawFd,
path: P,
flags: AtFlag
) -> Result<stat>
pub unsafe fn isatty(fd: RawFd) -> Result<bool>
pub unsafe fn linkat<P: AsRef<OsStr>>(
old_dirfd: RawFd,
old_path: P,
new_dirfd: RawFd,
new_path: P,
flags: AtFlag
) -> Result<()>
pub unsafe fn mkdirat<P: AsRef<OsStr>>(
dirfd: RawFd,
path: P,
mode: Mode
) -> Result<()>
pub unsafe fn openat<P: AsRef<OsStr>>(
dirfd: RawFd,
path: P,
oflag: OFlag,
mode: Mode
) -> Result<RawFd>
pub unsafe fn readlinkat<P: AsRef<OsStr>>(
dirfd: RawFd,
path: P
) -> Result<OsString>
pub unsafe fn renameat<P: AsRef<OsStr>>(
old_dirfd: RawFd,
old_path: P,
new_dirfd: RawFd,
new_path: P
) -> Result<()>
pub unsafe fn symlinkat<P: AsRef<OsStr>>(
old_path: P,
new_dirfd: RawFd,
new_path: P
) -> Result<()>
pub unsafe fn unlinkat<P: AsRef<OsStr>>(
dirfd: RawFd,
path: P,
flags: AtFlag
) -> Result<()>
| AtFlag | |
| FdFlag | |
| Mode | |
| OFlag | |
| SFlag |
| fionread⚠ |
|
| fstat⚠ | |
| fstatat⚠ | |
| isatty⚠ | |
| linkat⚠ | |
| mkdirat⚠ | |
| openat⚠ | |
| readlinkat⚠ | |
| renameat⚠ | |
| symlinkat⚠ | |
| unlinkat⚠ |
impl AtFlagpub const REMOVEDIR: AtFlagpub const SYMLINK_FOLLOW: AtFlagpub const SYMLINK_NOFOLLOW: AtFlagpub const fn empty() -> AtFlagReturns an empty set of flags
+pub const fn all() -> AtFlagReturns the set containing all flags.
+pub const fn bits(&self) -> c_intReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: c_int) -> Option<AtFlag>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: c_int) -> AtFlagConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: c_int) -> AtFlagConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: AtFlag) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: AtFlag) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: AtFlag)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: AtFlag)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: AtFlag)Toggles the specified flags in-place.
+pub fn set(&mut self, other: AtFlag, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for AtFlagimpl BitAnd<AtFlag> for AtFlagtype Output = AtFlagThe resulting type after applying the & operator.
fn bitand(self, other: AtFlag) -> AtFlagReturns the intersection between the two sets of flags.
+impl BitAndAssign<AtFlag> for AtFlagfn bitand_assign(&mut self, other: AtFlag)Disables all flags disabled in the set.
+impl BitOr<AtFlag> for AtFlagtype Output = AtFlagThe resulting type after applying the | operator.
fn bitor(self, other: AtFlag) -> AtFlagReturns the union of the two sets of flags.
+impl BitOrAssign<AtFlag> for AtFlagfn bitor_assign(&mut self, other: AtFlag)Adds the set of flags.
+impl BitXor<AtFlag> for AtFlagtype Output = AtFlagThe resulting type after applying the ^ operator.
fn bitxor(self, other: AtFlag) -> AtFlagReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<AtFlag> for AtFlagfn bitxor_assign(&mut self, other: AtFlag)Toggles the set of flags.
+impl Clone for AtFlagfn clone(&self) -> AtFlagfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for AtFlagimpl Debug for AtFlagimpl Eq for AtFlagimpl Extend<AtFlag> for AtFlagfn extend<T: IntoIterator<Item = AtFlag>>(&mut self, iterator: T)impl FromIterator<AtFlag> for AtFlagfn from_iter<T: IntoIterator<Item = AtFlag>>(iterator: T) -> AtFlagimpl Hash for AtFlagfn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for AtFlagimpl Not for AtFlagtype Output = AtFlagThe resulting type after applying the ! operator.
fn not(self) -> AtFlagReturns the complement of this set of flags.
+impl Octal for AtFlagimpl Ord for AtFlagfn cmp(&self, other: &AtFlag) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<AtFlag> for AtFlagimpl PartialOrd<AtFlag> for AtFlagfn partial_cmp(&self, other: &AtFlag) -> Option<Ordering>fn lt(&self, other: &AtFlag) -> boolfn le(&self, other: &AtFlag) -> boolfn gt(&self, other: &AtFlag) -> boolfn ge(&self, other: &AtFlag) -> boolimpl StructuralEq for AtFlagimpl StructuralPartialEq for AtFlagimpl Sub<AtFlag> for AtFlagtype Output = AtFlagThe resulting type after applying the - operator.
fn sub(self, other: AtFlag) -> AtFlagReturns the set difference of the two sets of flags.
+impl SubAssign<AtFlag> for AtFlagfn sub_assign(&mut self, other: AtFlag)Disables all flags enabled in the set.
+impl UpperHex for AtFlagimpl RefUnwindSafe for AtFlagimpl Send for AtFlagimpl Sync for AtFlagimpl Unpin for AtFlagimpl UnwindSafe for AtFlagimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl FdFlagpub const CLOEXEC: FdFlagpub const fn empty() -> FdFlagReturns an empty set of flags
+pub const fn all() -> FdFlagReturns the set containing all flags.
+pub const fn bits(&self) -> c_intReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: c_int) -> Option<FdFlag>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: c_int) -> FdFlagConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: c_int) -> FdFlagConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: FdFlag) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: FdFlag) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: FdFlag)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: FdFlag)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: FdFlag)Toggles the specified flags in-place.
+pub fn set(&mut self, other: FdFlag, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for FdFlagimpl BitAnd<FdFlag> for FdFlagtype Output = FdFlagThe resulting type after applying the & operator.
fn bitand(self, other: FdFlag) -> FdFlagReturns the intersection between the two sets of flags.
+impl BitAndAssign<FdFlag> for FdFlagfn bitand_assign(&mut self, other: FdFlag)Disables all flags disabled in the set.
+impl BitOr<FdFlag> for FdFlagtype Output = FdFlagThe resulting type after applying the | operator.
fn bitor(self, other: FdFlag) -> FdFlagReturns the union of the two sets of flags.
+impl BitOrAssign<FdFlag> for FdFlagfn bitor_assign(&mut self, other: FdFlag)Adds the set of flags.
+impl BitXor<FdFlag> for FdFlagtype Output = FdFlagThe resulting type after applying the ^ operator.
fn bitxor(self, other: FdFlag) -> FdFlagReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<FdFlag> for FdFlagfn bitxor_assign(&mut self, other: FdFlag)Toggles the set of flags.
+impl Clone for FdFlagfn clone(&self) -> FdFlagfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for FdFlagimpl Debug for FdFlagimpl Eq for FdFlagimpl Extend<FdFlag> for FdFlagfn extend<T: IntoIterator<Item = FdFlag>>(&mut self, iterator: T)impl FromIterator<FdFlag> for FdFlagfn from_iter<T: IntoIterator<Item = FdFlag>>(iterator: T) -> FdFlagimpl Hash for FdFlagfn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for FdFlagimpl Not for FdFlagtype Output = FdFlagThe resulting type after applying the ! operator.
fn not(self) -> FdFlagReturns the complement of this set of flags.
+impl Octal for FdFlagimpl Ord for FdFlagfn cmp(&self, other: &FdFlag) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<FdFlag> for FdFlagimpl PartialOrd<FdFlag> for FdFlagfn partial_cmp(&self, other: &FdFlag) -> Option<Ordering>fn lt(&self, other: &FdFlag) -> boolfn le(&self, other: &FdFlag) -> boolfn gt(&self, other: &FdFlag) -> boolfn ge(&self, other: &FdFlag) -> boolimpl StructuralEq for FdFlagimpl StructuralPartialEq for FdFlagimpl Sub<FdFlag> for FdFlagtype Output = FdFlagThe resulting type after applying the - operator.
fn sub(self, other: FdFlag) -> FdFlagReturns the set difference of the two sets of flags.
+impl SubAssign<FdFlag> for FdFlagfn sub_assign(&mut self, other: FdFlag)Disables all flags enabled in the set.
+impl UpperHex for FdFlagimpl RefUnwindSafe for FdFlagimpl Send for FdFlagimpl Sync for FdFlagimpl Unpin for FdFlagimpl UnwindSafe for FdFlagimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl Modepub const IRWXU: Modepub const IRUSR: Modepub const IWUSR: Modepub const IXUSR: Modepub const IRWXG: Modepub const IRGRP: Modepub const IWGRP: Modepub const IXGRP: Modepub const IRWXO: Modepub const IROTH: Modepub const IWOTH: Modepub const IXOTH: Modepub const ISUID: Modepub const ISGID: Modepub const ISVTX: Modepub const fn empty() -> ModeReturns an empty set of flags
+pub const fn all() -> ModeReturns the set containing all flags.
+pub const fn bits(&self) -> mode_tReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: mode_t) -> Option<Mode>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: mode_t) -> ModeConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: mode_t) -> ModeConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: Mode) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: Mode) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: Mode)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: Mode)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: Mode)Toggles the specified flags in-place.
+pub fn set(&mut self, other: Mode, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for Modeimpl BitAnd<Mode> for Modetype Output = ModeThe resulting type after applying the & operator.
fn bitand(self, other: Mode) -> ModeReturns the intersection between the two sets of flags.
+impl BitAndAssign<Mode> for Modefn bitand_assign(&mut self, other: Mode)Disables all flags disabled in the set.
+impl BitOr<Mode> for Modetype Output = ModeThe resulting type after applying the | operator.
fn bitor(self, other: Mode) -> ModeReturns the union of the two sets of flags.
+impl BitOrAssign<Mode> for Modefn bitor_assign(&mut self, other: Mode)Adds the set of flags.
+impl BitXor<Mode> for Modetype Output = ModeThe resulting type after applying the ^ operator.
fn bitxor(self, other: Mode) -> ModeReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<Mode> for Modefn bitxor_assign(&mut self, other: Mode)Toggles the set of flags.
+impl Clone for Modefn clone(&self) -> Modefn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for Modeimpl Debug for Modeimpl Eq for Modeimpl Extend<Mode> for Modefn extend<T: IntoIterator<Item = Mode>>(&mut self, iterator: T)impl FromIterator<Mode> for Modefn from_iter<T: IntoIterator<Item = Mode>>(iterator: T) -> Modeimpl Hash for Modefn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for Modeimpl Not for Modetype Output = ModeThe resulting type after applying the ! operator.
fn not(self) -> ModeReturns the complement of this set of flags.
+impl Octal for Modeimpl Ord for Modefn cmp(&self, other: &Mode) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<Mode> for Modeimpl PartialOrd<Mode> for Modefn partial_cmp(&self, other: &Mode) -> Option<Ordering>fn lt(&self, other: &Mode) -> boolfn le(&self, other: &Mode) -> boolfn gt(&self, other: &Mode) -> boolfn ge(&self, other: &Mode) -> boolimpl StructuralEq for Modeimpl StructuralPartialEq for Modeimpl Sub<Mode> for Modetype Output = ModeThe resulting type after applying the - operator.
fn sub(self, other: Mode) -> ModeReturns the set difference of the two sets of flags.
+impl SubAssign<Mode> for Modefn sub_assign(&mut self, other: Mode)Disables all flags enabled in the set.
+impl UpperHex for Modeimpl RefUnwindSafe for Modeimpl Send for Modeimpl Sync for Modeimpl Unpin for Modeimpl UnwindSafe for Modeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl OFlagpub const ACCMODE: OFlagpub const APPEND: OFlagpub const CREAT: OFlagpub const DIRECTORY: OFlagpub const DSYNC: OFlagpub const EXCL: OFlagpub const FSYNC: OFlagpub const NOFOLLOW: OFlagpub const NONBLOCK: OFlagpub const RDONLY: OFlagpub const WRONLY: OFlagpub const RDWR: OFlagpub const RSYNC: OFlagpub const SYNC: OFlagpub const TRUNC: OFlagpub const fn empty() -> OFlagReturns an empty set of flags
+pub const fn all() -> OFlagReturns the set containing all flags.
+pub const fn bits(&self) -> c_intReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: c_int) -> Option<OFlag>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: c_int) -> OFlagConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: c_int) -> OFlagConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: OFlag) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: OFlag) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: OFlag)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: OFlag)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: OFlag)Toggles the specified flags in-place.
+pub fn set(&mut self, other: OFlag, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for OFlagimpl BitAnd<OFlag> for OFlagtype Output = OFlagThe resulting type after applying the & operator.
fn bitand(self, other: OFlag) -> OFlagReturns the intersection between the two sets of flags.
+impl BitAndAssign<OFlag> for OFlagfn bitand_assign(&mut self, other: OFlag)Disables all flags disabled in the set.
+impl BitOr<OFlag> for OFlagtype Output = OFlagThe resulting type after applying the | operator.
fn bitor(self, other: OFlag) -> OFlagReturns the union of the two sets of flags.
+impl BitOrAssign<OFlag> for OFlagfn bitor_assign(&mut self, other: OFlag)Adds the set of flags.
+impl BitXor<OFlag> for OFlagtype Output = OFlagThe resulting type after applying the ^ operator.
fn bitxor(self, other: OFlag) -> OFlagReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<OFlag> for OFlagfn bitxor_assign(&mut self, other: OFlag)Toggles the set of flags.
+impl Clone for OFlagfn clone(&self) -> OFlagfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for OFlagimpl Debug for OFlagimpl Eq for OFlagimpl Extend<OFlag> for OFlagfn extend<T: IntoIterator<Item = OFlag>>(&mut self, iterator: T)impl FromIterator<OFlag> for OFlagfn from_iter<T: IntoIterator<Item = OFlag>>(iterator: T) -> OFlagimpl Hash for OFlagfn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for OFlagimpl Not for OFlagtype Output = OFlagThe resulting type after applying the ! operator.
fn not(self) -> OFlagReturns the complement of this set of flags.
+impl Octal for OFlagimpl Ord for OFlagfn cmp(&self, other: &OFlag) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<OFlag> for OFlagimpl PartialOrd<OFlag> for OFlagfn partial_cmp(&self, other: &OFlag) -> Option<Ordering>fn lt(&self, other: &OFlag) -> boolfn le(&self, other: &OFlag) -> boolfn gt(&self, other: &OFlag) -> boolfn ge(&self, other: &OFlag) -> boolimpl StructuralEq for OFlagimpl StructuralPartialEq for OFlagimpl Sub<OFlag> for OFlagtype Output = OFlagThe resulting type after applying the - operator.
fn sub(self, other: OFlag) -> OFlagReturns the set difference of the two sets of flags.
+impl SubAssign<OFlag> for OFlagfn sub_assign(&mut self, other: OFlag)Disables all flags enabled in the set.
+impl UpperHex for OFlagimpl RefUnwindSafe for OFlagimpl Send for OFlagimpl Sync for OFlagimpl Unpin for OFlagimpl UnwindSafe for OFlagimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl SFlagpub const IFIFO: SFlagpub const IFCHR: SFlagpub const IFDIR: SFlagpub const IFBLK: SFlagpub const IFREG: SFlagpub const IFLNK: SFlagpub const IFSOCK: SFlagpub const IFMT: SFlagpub const fn empty() -> SFlagReturns an empty set of flags
+pub const fn all() -> SFlagReturns the set containing all flags.
+pub const fn bits(&self) -> mode_tReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: mode_t) -> Option<SFlag>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: mode_t) -> SFlagConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: mode_t) -> SFlagConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: SFlag) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: SFlag) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: SFlag)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: SFlag)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: SFlag)Toggles the specified flags in-place.
+pub fn set(&mut self, other: SFlag, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for SFlagimpl BitAnd<SFlag> for SFlagtype Output = SFlagThe resulting type after applying the & operator.
fn bitand(self, other: SFlag) -> SFlagReturns the intersection between the two sets of flags.
+impl BitAndAssign<SFlag> for SFlagfn bitand_assign(&mut self, other: SFlag)Disables all flags disabled in the set.
+impl BitOr<SFlag> for SFlagtype Output = SFlagThe resulting type after applying the | operator.
fn bitor(self, other: SFlag) -> SFlagReturns the union of the two sets of flags.
+impl BitOrAssign<SFlag> for SFlagfn bitor_assign(&mut self, other: SFlag)Adds the set of flags.
+impl BitXor<SFlag> for SFlagtype Output = SFlagThe resulting type after applying the ^ operator.
fn bitxor(self, other: SFlag) -> SFlagReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<SFlag> for SFlagfn bitxor_assign(&mut self, other: SFlag)Toggles the set of flags.
+impl Clone for SFlagfn clone(&self) -> SFlagfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for SFlagimpl Debug for SFlagimpl Eq for SFlagimpl Extend<SFlag> for SFlagfn extend<T: IntoIterator<Item = SFlag>>(&mut self, iterator: T)impl FromIterator<SFlag> for SFlagfn from_iter<T: IntoIterator<Item = SFlag>>(iterator: T) -> SFlagimpl Hash for SFlagfn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for SFlagimpl Not for SFlagtype Output = SFlagThe resulting type after applying the ! operator.
fn not(self) -> SFlagReturns the complement of this set of flags.
+impl Octal for SFlagimpl Ord for SFlagfn cmp(&self, other: &SFlag) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<SFlag> for SFlagimpl PartialOrd<SFlag> for SFlagfn partial_cmp(&self, other: &SFlag) -> Option<Ordering>fn lt(&self, other: &SFlag) -> boolfn le(&self, other: &SFlag) -> boolfn gt(&self, other: &SFlag) -> boolfn ge(&self, other: &SFlag) -> boolimpl StructuralEq for SFlagimpl StructuralPartialEq for SFlagimpl Sub<SFlag> for SFlagtype Output = SFlagThe resulting type after applying the - operator.
fn sub(self, other: SFlag) -> SFlagReturns the set difference of the two sets of flags.
+impl SubAssign<SFlag> for SFlagfn sub_assign(&mut self, other: SFlag)Disables all flags enabled in the set.
+impl UpperHex for SFlagimpl RefUnwindSafe for SFlagimpl Send for SFlagimpl Sync for SFlagimpl Unpin for SFlagimpl UnwindSafe for SFlagimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]yanix stands for Yet Another Nix crate, and, well, it is simply
+a yet another crate in the spirit of the nix crate. As such,
+this crate is inspired by the original nix crate, however,
+it takes a different approach, using lower-level interfaces with
+less abstraction, so that it fits better with its main use case
+which is our WASI implementation, wasi-common.
| clock | |
| dir | |
| fadvise | |
| fcntl | |
| file | |
| poll | |
| socket |
| Errno | |
| YanixError |
| Result |
pub fn poll(fds: &mut [PollFd], timeout: c_int) -> Result<usize>
| PollFd | |
| PollFlags |
| poll |
impl PollFd[src]pub unsafe fn new(fd: RawFd, events: PollFlags) -> Self[src]pub fn revents(self) -> Option<PollFlags>[src]impl Clone for PollFd[src]impl Copy for PollFd[src]impl Debug for PollFd[src]impl Eq for PollFd[src]impl Hash for PollFd[src]fn hash<__H: Hasher>(&self, state: &mut __H)[src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<PollFd> for PollFd[src]impl StructuralEq for PollFd[src]impl StructuralPartialEq for PollFd[src]impl RefUnwindSafe for PollFdimpl Send for PollFdimpl Sync for PollFdimpl Unpin for PollFdimpl UnwindSafe for PollFdimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl PollFlagspub const POLLIN: PollFlagspub const POLLPRI: PollFlagspub const POLLOUT: PollFlagspub const POLLRDNORM: PollFlagspub const POLLWRNORM: PollFlagspub const POLLRDBAND: PollFlagspub const POLLWRBAND: PollFlagspub const POLLERR: PollFlagspub const POLLHUP: PollFlagspub const POLLNVAL: PollFlagspub const fn empty() -> PollFlagsReturns an empty set of flags
+pub const fn all() -> PollFlagsReturns the set containing all flags.
+pub const fn bits(&self) -> c_shortReturns the raw value of the flags currently stored.
+pub fn from_bits(bits: c_short) -> Option<PollFlags>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+pub const fn from_bits_truncate(bits: c_short) -> PollFlagsConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+pub const unsafe fn from_bits_unchecked(bits: c_short) -> PollFlagsConvert from underlying bit representation, preserving all +bits (even those not corresponding to a defined flag).
+pub const fn is_empty(&self) -> boolReturns true if no flags are currently stored.
pub const fn is_all(&self) -> boolReturns true if all flags are currently set.
pub const fn intersects(&self, other: PollFlags) -> boolReturns true if there are flags common to both self and other.
pub const fn contains(&self, other: PollFlags) -> boolReturns true all of the flags in other are contained within self.
pub fn insert(&mut self, other: PollFlags)Inserts the specified flags in-place.
+pub fn remove(&mut self, other: PollFlags)Removes the specified flags in-place.
+pub fn toggle(&mut self, other: PollFlags)Toggles the specified flags in-place.
+pub fn set(&mut self, other: PollFlags, value: bool)Inserts or removes the specified flags depending on the passed value.
+impl Binary for PollFlagsimpl BitAnd<PollFlags> for PollFlagstype Output = PollFlagsThe resulting type after applying the & operator.
fn bitand(self, other: PollFlags) -> PollFlagsReturns the intersection between the two sets of flags.
+impl BitAndAssign<PollFlags> for PollFlagsfn bitand_assign(&mut self, other: PollFlags)Disables all flags disabled in the set.
+impl BitOr<PollFlags> for PollFlagstype Output = PollFlagsThe resulting type after applying the | operator.
fn bitor(self, other: PollFlags) -> PollFlagsReturns the union of the two sets of flags.
+impl BitOrAssign<PollFlags> for PollFlagsfn bitor_assign(&mut self, other: PollFlags)Adds the set of flags.
+impl BitXor<PollFlags> for PollFlagstype Output = PollFlagsThe resulting type after applying the ^ operator.
fn bitxor(self, other: PollFlags) -> PollFlagsReturns the left flags, but with all the right flags toggled.
+impl BitXorAssign<PollFlags> for PollFlagsfn bitxor_assign(&mut self, other: PollFlags)Toggles the set of flags.
+impl Clone for PollFlagsfn clone(&self) -> PollFlagsfn clone_from(&mut self, source: &Self)1.0.0[src]impl Copy for PollFlagsimpl Debug for PollFlagsimpl Eq for PollFlagsimpl Extend<PollFlags> for PollFlagsfn extend<T: IntoIterator<Item = PollFlags>>(&mut self, iterator: T)impl FromIterator<PollFlags> for PollFlagsfn from_iter<T: IntoIterator<Item = PollFlags>>(iterator: T) -> PollFlagsimpl Hash for PollFlagsfn hash<__H: Hasher>(&self, state: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl LowerHex for PollFlagsimpl Not for PollFlagstype Output = PollFlagsThe resulting type after applying the ! operator.
fn not(self) -> PollFlagsReturns the complement of this set of flags.
+impl Octal for PollFlagsimpl Ord for PollFlagsfn cmp(&self, other: &PollFlags) -> Ordering#[must_use]
+fn max(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn min(self, other: Self) -> Self1.21.0[src]#[must_use]
+fn clamp(self, min: Self, max: Self) -> Self[src]impl PartialEq<PollFlags> for PollFlagsimpl PartialOrd<PollFlags> for PollFlagsfn partial_cmp(&self, other: &PollFlags) -> Option<Ordering>fn lt(&self, other: &PollFlags) -> boolfn le(&self, other: &PollFlags) -> boolfn gt(&self, other: &PollFlags) -> boolfn ge(&self, other: &PollFlags) -> boolimpl StructuralEq for PollFlagsimpl StructuralPartialEq for PollFlagsimpl Sub<PollFlags> for PollFlagstype Output = PollFlagsThe resulting type after applying the - operator.
fn sub(self, other: PollFlags) -> PollFlagsReturns the set difference of the two sets of flags.
+impl SubAssign<PollFlags> for PollFlagsfn sub_assign(&mut self, other: PollFlags)Disables all flags enabled in the set.
+impl UpperHex for PollFlagsimpl RefUnwindSafe for PollFlagsimpl Send for PollFlagsimpl Sync for PollFlagsimpl Unpin for PollFlagsimpl UnwindSafe for PollFlagsimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]impl RefUnwindSafe for SockTypeimpl Send for SockTypeimpl Sync for SockTypeimpl Unpin for SockTypeimpl UnwindSafe for SockTypeimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]pub unsafe fn get_socket_type(fd: RawFd) -> Result<SockType>
| SockType |
| get_socket_type⚠ |
Redirecting to ../../../../yanix/fadvise/enum.PosixFadviseAdvice.html...
+ + + \ No newline at end of file diff --git a/api/yanix/sys/linux/fadvise/fn.posix_fadvise.html b/api/yanix/sys/linux/fadvise/fn.posix_fadvise.html new file mode 100644 index 000000000000..0bda02cd3a76 --- /dev/null +++ b/api/yanix/sys/linux/fadvise/fn.posix_fadvise.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../yanix/fadvise/fn.posix_fadvise.html...
+ + + \ No newline at end of file diff --git a/api/yanix/sys/linux/file/fn.isatty.html b/api/yanix/sys/linux/file/fn.isatty.html new file mode 100644 index 000000000000..ee089b494e77 --- /dev/null +++ b/api/yanix/sys/linux/file/fn.isatty.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../../../yanix/file/fn.isatty.html...
+ + + \ No newline at end of file diff --git a/api/yanix/sys/trait.EntryExt.html b/api/yanix/sys/trait.EntryExt.html new file mode 100644 index 000000000000..5528b21579d2 --- /dev/null +++ b/api/yanix/sys/trait.EntryExt.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../yanix/dir/trait.EntryExt.html...
+ + + \ No newline at end of file diff --git a/api/yanix/type.Result.html b/api/yanix/type.Result.html new file mode 100644 index 000000000000..1326110d423c --- /dev/null +++ b/api/yanix/type.Result.html @@ -0,0 +1 @@ +type Result<T> = Result<T, YanixError>;
wasmtimeThe configuration file uses the toml format. +You can create a configuration file at the default location with:
+$ wasmtime config new
+It will print the location regardless of the success.
+Please refer to the --help message for using a custom location.
All settings, except enabled, are optional.
+If the setting is not specified, the default value is used.
+Thus, if you don't know what values to use, don't specify them.
+The default values might be tuned in the future.
Wasmtime assumes all the options are in the cache section.
Example config:
+[cache]
+enabled = true
+directory = "/nfs-share/wasmtime-cache/"
+cleanup-interval = "30m"
+files-total-size-soft-limit = "1Gi"
+Please refer to the cache system section to learn how it works.
+If you think some default value should be tuned, some new settings +should be introduced or some behavior should be changed, you are +welcome to discuss it and contribute to the Wasmtime repository.
+enabledtrue | falsetrueSpecifies whether the cache system is used or not.
+This field is mandatory. +The default value is used when configuration file is not specified +and none exists at the default location.
+directorycache_dir in directories crateSpecifies where the cache directory is. Must be an absolute path.
+worker-event-queue-size"{integer}(K | M | G | T | P)?""16"Size of cache worker event queue. +If the queue is full, incoming cache usage events will be dropped.
+baseline-compression-level3, the default zstd compression levelCompression level used when a new cache file is being written by the cache system. +Wasmtime uses zstd compression.
+optimized-compression-level20Compression level used when the cache worker decides to recompress a cache file. +Wasmtime uses zstd compression.
+optimized-compression-usage-counter-threshold"{integer}(K | M | G | T | P)?""256"One of the conditions for the cache worker to recompress a cache file +is to have usage count of the file exceeding this threshold.
+cleanup-interval"{integer}(s | m | h | d)""1h"When the cache worker is notified about a cache file being updated by the cache system +and this interval has already passed since last cleaning up, +the worker will attempt a new cleanup.
+Please also refer to allowed-clock-drift-for-files-from-future.
optimizing-compression-task-timeout"{integer}(s | m | h | d)""30m"When the cache worker decides to recompress a cache file, it makes sure that
+no other worker has started the task for this file within the last
+optimizing-compression-task-timeout interval.
+If some worker has started working on it, other workers are skipping this task.
Please also refer to the allowed-clock-drift-for-files-from-future section.
allowed-clock-drift-for-files-from-future"{integer}(s | m | h | d)""1d"When the cache worker attempts acquiring a lock for some task, +it checks if some other worker has already acquired such a lock. +To be fault tolerant and eventually execute every task, +the locks expire after some interval. +However, because of clock drifts and different timezones, +it would happen that some lock was created in the future. +This setting defines a tolerance limit for these locks. +If the time has been changed in the system (i.e. two years backwards), +the cache system should still work properly. +Thus, these locks will be treated as expired +(assuming the tolerance is not too big).
+Similarly to the locks, the cache files or their metadata might +have modification time in distant future. +The cache system tries to keep these files as long as possible. +If the limits are not reached, the cache files will not be deleted. +Otherwise, they will be treated as the oldest files, so they might survive. +If the user actually uses the cache file, the modification time will be updated.
+file-count-soft-limit"{integer}(K | M | G | T | P)?""65536"Soft limit for the file count in the cache directory.
+This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+files-total-size-soft-limit"{integer}(K | Ki | M | Mi | G | Gi | T | Ti | P | Pi)?""512Mi"Soft limit for the total size* of files in the cache directory.
+This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+*this is the file size, not the space physically occupied on the disk.
+file-count-limit-percent-if-deleting"{integer}%""70%"If file-count-soft-limit is exceeded and the cache worker performs the cleanup task,
+then the worker will delete some cache files, so after the task,
+the file count should not exceed
+file-count-soft-limit * file-count-limit-percent-if-deleting.
This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+files-total-size-limit-percent-if-deleting"{integer}%""70%"If files-total-size-soft-limit is exceeded and cache worker performs the cleanup task,
+then the worker will delete some cache files, so after the task,
+the files total size should not exceed
+files-total-size-soft-limit * files-total-size-limit-percent-if-deleting.
This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+This is an implementation detail and might change in the future. +Information provided here is meant to help understanding the big picture +and configuring the cache.
+There are two main components - the cache system and the cache worker.
+Handles GET and UPDATE cache requests.
+baseline-compression-level, then writes the data to the disk.In case of successful handling of a request, it notifies the cache worker about this
+event using the queue.
+The queue has a limited size of worker-event-queue-size. If it is full, it will drop
+new events until the cache worker pops some event from the queue.
The cache worker runs in a single thread with lower priority and pops events from the queue +in a loop handling them one by one.
+Read the statistics file for the cache file, +increase the usage counter and write it back to the disk.
+Attempt recompressing the cache file if all of the following conditions are met:
+optimized-compression-usage-counter-threshold,optimized-compression-level,optimizing-compression-task-timeout interval.When recompressing, optimized-compression-level is used as a compression level.
cleanup-interval.
+During this task:
+file-count-soft-limit or files-total-size-soft-limit is exceeded,
+then recognized files will be deleted according to
+file-count-limit-percent-if-deleting and files-total-size-limit-percent-if-deleting.
+Wasmtime uses Least Recently Used (LRU) cache replacement policy and requires that
+the filesystem maintains proper mtime (modification time) of the files.
+Files with future mtimes are treated specially - more details
+in allowed-clock-drift-for-files-from-future.wasmtime... more coming soon
+ +wasmtime... more coming soon
+ +wasmtime CLI... more coming soon
+ +This section describes everything required to build and run Wasmtime.
+Before we can actually build Wasmtime, we'll need to make sure these things are +installed first.
+Install the Rust toolchain here. This
+includes rustup, cargo, rustc, etc...
libclang (optional)The wasmtime-fuzzing crate transitively depends on bindgen, which requires
+that your system has a libclang installed. Therefore, if you want to hack on
+Wasmtime's fuzzing infrastructure, you'll need libclang. Details on how to
+get libclang and make it available for bindgen are
+here.
wasmtime CLITo make an unoptimized, debug build of the wasmtime CLI tool, go to the root
+of the repository and run this command:
cargo build
+The built executable will be located at target/debug/wasmtime.
To make an optimized build, run this command in the root of the repository:
+cargo build --release
+The built executable will be located at target/release/wasmtime.
You can also build and run a local wasmtime CLI by replacing cargo build
+with cargo run.
You can build any of the Wasmtime crates by appending -p wasmtime-whatever to
+the cargo build invocation. For example, to build the wasmtime-jit crate,
+execute this command:
cargo build -p wasmtime-jit
+Alternatively, you can cd into the crate's directory, and run cargo build
+there, without needing to supply the -p flag:
cd crates/jit/
+cargo build
+... more coming soon
+ +Note: this Code of Conduct pertains to individuals' behavior. Please also see the Organizational Code of Conduct.
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+Examples of behavior that contributes to creating a positive environment include:
+Examples of unacceptable behavior by participants include:
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the Bytecode Alliance CoC team at report@bytecodealliance.org. The CoC team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The CoC team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the Bytecode Alliance's leadership.
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at http://contributor-covenant.org/version/1/4
+ +Test case generators and oracles live in the wasmtime-fuzzing crate, located
+in the crates/fuzzing directory.
A test case generator takes raw, unstructured input from a fuzzer and +translates that into a test case. This might involve interpreting the raw input +as "DNA" or pre-determined choices through a decision tree and using it to +generate an in-memory data structure, or it might be a no-op where we interpret +the raw bytes as if they were Wasm.
+An oracle takes a test case and determines whether we have a bug. For example, +one of the simplest oracles is to take a Wasm binary as an input test case, +validate and instantiate it, and (implicitly) check that no assertions failed or +segfaults happened. A more complicated oracle might compare the result of +executing a Wasm file with and without optimizations enabled, and make sure that +the two executions are observably identical.
+Our test case generators and oracles strive to be fuzzer-agnostic: they can be +reused with libFuzzer or AFL or any other fuzzing engine or driver.
+cargo fuzz Fuzz TargetsWe combine a test case generator and one more more oracles into a fuzz +target. Because the target needs to pipe the raw input from a fuzzer into the +test case generator, it is specific to a particular fuzzer. This is generally +fine, since they're only a couple of lines of glue code.
+Currently, all of our fuzz targets are written for
+libFuzzer and cargo fuzz. They are defined in
+the fuzz subdirectory.
See
+fuzz/README.md
+for details on how to run these fuzz targets and set up a corpus of seed inputs.
... more coming soon
+ +This section describes how to run Wasmtime's tests and add new tests.
+Before continuing, make sure you can build +Wasmtime successfully. Can't run the tests if you +can't build it!
+To run all of Wasmtime's tests (excluding WASI integration tests), execute this command:
+cargo test --all
+To include WASI integration tests, you'll need wasm32-wasi target installed, which,
+assuming you're using rustup.rs to manage your Rust versions,
+can be done as follows:
rustup target add wasm32-wasi
+Next, to run all tests including the WASI integration tests, execute this command:
+cargo test --features test_programs --all
+You can also exclude a particular crate from testing with --exclude. For
+example, if you want to avoid testing the wastime-fuzzing crate — which
+requires that libclang is installed on your system, and for some reason maybe
+you don't have it — you can run:
cargo test --all --exclude wasmtime-fuzzing
+You can test a particular Wasmtime crate with cargo test -p wasmtime-whatever. For example, to test the wasmtime-environ crate, execute
+this command:
cargo test -p wasmtime-environ
+Alternatively, you can cd into the crate's directory, and run cargo test
+there, without needing to supply the -p flag:
cd crates/environ/
+cargo test
+The spec testsuite itself is in a git submodule, so make sure you've +checked it out and initialized its submodule:
+git submodule update --init
+When the submodule is checked out, Wasmtime runs the Wasm spec testsuite as part
+of testing the wasmtime-cli crate:
cargo test -p wasmtime-cli
+WASI integration tests can be run separately from all other tests which
+can be useful when working on the wasi-common crate. This can be done by
+executing this command:
cargo test --features test_programs -p test-programs
+#[test]-Style TestsFor very "unit-y" tests, we add test modules in the same .rs file as the
+code that is being tested. These test modules are configured to only get
+compiled during testing with #[cfg(test)].
++# #![allow(unused_variables)] +#fn main() { +// some code... + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn some_test_for_that_code() { + // ... + } +} +#}
If you're writing a unit test and a test module doesn't already exist, you can
+create one.
For more "integration-y" tests, we create a tests directory within the crate,
+and put the tests inside there. For example, there are various code
+cache-related tests at crates/environ/tests/cache_*.rs. Always feel free to
+add a tests directory to a crate, if you want to add a new test and there
+aren't any existing tests.
We use the spec testsuite as-is and without custom patches or a forked +version. This probably isn't what you want to modify when adding a new Wasmtime +test!
+When you have a Wasmtime-specific test that you'd like to write in Wast and use
+the Wast-style assertions, you can add it to our "misc testsuite". The misc
+testsuite uses the same syntax and assertions as the spec testsuite, but lives
+in tests/misc_testsuite. Feel free to add new tests to existing
+tests/misc_testsuite/*.wast files or create new ones as needed. These tests
+are run as part of the wasmtime-cli crate's tests.
If you have a new test that you think really belongs in the spec testsuite, make +sure it makes sense for every Wasm implementation to run your test (i.e. it +isn't Wasmtime-specific) and send a pull request +upstream. Once it is accepted in +the upstream repo, we can update our git submodule and we'll start running the +new tests.
+When you have a WASI-specific test program that you'd like to include as a
+test case to run against our WASI implementation, you can add it to our
+test-programs crate. In particular, you should drop a main-style Rust source
+file into crates/test-programs/wasi-tests/src/bin/some_new_test.rs with a
+name of your choice. And that's it! The build script included in the
+test-programs crate will automatically generate the necessary boilerplate
+code for your test program so that it's run on all supported hosts.
If you would like to tweak which host to run the test program against however
+(for instance, only on Unix but on Windows), you can tweak that in the build
+script located under crates/test-programs/build.rs.
We're excited to work on Wasmtime together with you! This guide should help you +get up and running with Wasmtime development. But first, make sure you've read +the Code of Conduct!
+We chat about Wasmtime development on Gitter — join +us!
+If you're having trouble building Wasmtime, aren't sure why a test is failing, +or have any other questions, feel free to ask here. You can also open an +issue!
+If you're looking for something to do, these are great places to start:
+Issues labeled "good first +issue" +— these issues tend to be simple, what needs to be done is well known, +and are good for new contributors to tackle. The goal is to learn Wasmtime's +development workflow and make sure that you can build and test Wasmtime.
+Issues labeled "help +wanted" +— these are issues that we need a little help with!
+If you're unsure if an issue is a good fit for you or not, feel free to ask in a +comment on the issue, or in chat.
+ +... more coming soon
+ +This document shows how to embed Wasmtime using the Rust API, and run a simple +wasm program.
+Let's create a simple WebAssembly file with a single exported function that returns an integer:
+(;; wat2wasm hello.wat -o $WASM_FILES/hello.wasm ;;)
+(module
+ (func (export "answer") (result i32)
+ i32.const 42
+ )
+)
+$ cargo new --bin wasmtime_hello
+$ cd wasmtime_hello
+$ cp $WASM_FILES/hello.wasm .
+We will be using the wasmtime engine/API to run the wasm file, so we will add the dependency to Cargo.toml:
[dependencies]
+wasmtime = "<current version>"
+where "wasmtime crate.
It is time to add code to the src/main.rs. First, storage needs to be activated:
++# #![allow(unused_variables)] +#fn main() { +use wasmtime::*; + +let store = Store::default(); +#}
The HostRef will be used a lot -- it is a "convenience" object to store and refer an object between the host and
+the embedded environments.
The hello.wasm can be read from the file system and provided to the Module object constructor as &[u8]:
++# #![allow(unused_variables)] +#fn main() { +use std::fs::read; + +let hello_wasm = read("hello.wasm").expect("wasm file"); + +let module = HostRef::new(Module::new(&store, &hello_wasm).expect("wasm module")); +#}
The module instance can now be created. Normally, you would provide exports, but in this case, there are none required:
+++# #![allow(unused_variables)] +#fn main() { +let instance = Instance::new(&store, &module, &[]).expect("wasm instance"); +#}
Everything is set. If a WebAssembly module has a start function -- it was run. +The instance's exports can be used at this point. wasmtime provides functions +to look up an export by name, and ensure that it's a function:
+++# #![allow(unused_variables)] +#fn main() { +let answer = instance.find_export_by_name("answer").expect("answer").func().expect("function"); +#}
The exported function can be called using the call method. Remember that in most of the cases,
+a HostRef<_> object will be returned, so borrow() or borrow_mut() method has to be used to refer the
+specific object. The exported "answer" function accepts no parameters and returns a single i32 value.
++# #![allow(unused_variables)] +#fn main() { +let result = answer.borrow().call(&[]).expect("success"); +println!("Answer: {}", result[0].i32()); +#}
The names of the WebAssembly module's imports and exports can be discovered by means of module's corresponding methods.
++ +use std::fs::read; +use wasmtime::*; + +fn main() { + let store = Store::default(); + + let wasm = read("hello.wasm").expect("wasm file"); + + let module = HostRef::new(Module::new(&store, &wasm).expect("wasm module")); + let instance = Instance::new(&store, &module, &[]).expect("wasm instance"); + + let answer = instance.find_export_by_name("answer").expect("answer").func().expect("function"); + let result = answer.borrow().call(&[]).expect("success"); + println!("Answer: {}", result[0].i32()); +} +
... more coming soon
+ +... more coming soon
+ +This is an explanation of all examples to come
+... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+... more coming soon
+hello-world.wasm... more coming soon
+hello-world.wasm with Wasmtime... more coming soon
+This is an explanation of all examples to come
+... more coming soon
+... more coming soon
+... more coming soon
+... more coming soon
+... more coming soon
+... more coming soon
+... more coming soon
+wasmtime CLI... more coming soon
+wasmtime... more coming soon
+wasmtime... more coming soon
+wasmtimeThe configuration file uses the toml format. +You can create a configuration file at the default location with:
+$ wasmtime config new
+It will print the location regardless of the success.
+Please refer to the --help message for using a custom location.
All settings, except enabled, are optional.
+If the setting is not specified, the default value is used.
+Thus, if you don't know what values to use, don't specify them.
+The default values might be tuned in the future.
Wasmtime assumes all the options are in the cache section.
Example config:
+[cache]
+enabled = true
+directory = "/nfs-share/wasmtime-cache/"
+cleanup-interval = "30m"
+files-total-size-soft-limit = "1Gi"
+Please refer to the cache system section to learn how it works.
+If you think some default value should be tuned, some new settings +should be introduced or some behavior should be changed, you are +welcome to discuss it and contribute to the Wasmtime repository.
+enabledtrue | falsetrueSpecifies whether the cache system is used or not.
+This field is mandatory. +The default value is used when configuration file is not specified +and none exists at the default location.
+directorycache_dir in directories crateSpecifies where the cache directory is. Must be an absolute path.
+worker-event-queue-size"{integer}(K | M | G | T | P)?""16"Size of cache worker event queue. +If the queue is full, incoming cache usage events will be dropped.
+baseline-compression-level3, the default zstd compression levelCompression level used when a new cache file is being written by the cache system. +Wasmtime uses zstd compression.
+optimized-compression-level20Compression level used when the cache worker decides to recompress a cache file. +Wasmtime uses zstd compression.
+optimized-compression-usage-counter-threshold"{integer}(K | M | G | T | P)?""256"One of the conditions for the cache worker to recompress a cache file +is to have usage count of the file exceeding this threshold.
+cleanup-interval"{integer}(s | m | h | d)""1h"When the cache worker is notified about a cache file being updated by the cache system +and this interval has already passed since last cleaning up, +the worker will attempt a new cleanup.
+Please also refer to allowed-clock-drift-for-files-from-future.
optimizing-compression-task-timeout"{integer}(s | m | h | d)""30m"When the cache worker decides to recompress a cache file, it makes sure that
+no other worker has started the task for this file within the last
+optimizing-compression-task-timeout interval.
+If some worker has started working on it, other workers are skipping this task.
Please also refer to the allowed-clock-drift-for-files-from-future section.
allowed-clock-drift-for-files-from-future"{integer}(s | m | h | d)""1d"When the cache worker attempts acquiring a lock for some task, +it checks if some other worker has already acquired such a lock. +To be fault tolerant and eventually execute every task, +the locks expire after some interval. +However, because of clock drifts and different timezones, +it would happen that some lock was created in the future. +This setting defines a tolerance limit for these locks. +If the time has been changed in the system (i.e. two years backwards), +the cache system should still work properly. +Thus, these locks will be treated as expired +(assuming the tolerance is not too big).
+Similarly to the locks, the cache files or their metadata might +have modification time in distant future. +The cache system tries to keep these files as long as possible. +If the limits are not reached, the cache files will not be deleted. +Otherwise, they will be treated as the oldest files, so they might survive. +If the user actually uses the cache file, the modification time will be updated.
+file-count-soft-limit"{integer}(K | M | G | T | P)?""65536"Soft limit for the file count in the cache directory.
+This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+files-total-size-soft-limit"{integer}(K | Ki | M | Mi | G | Gi | T | Ti | P | Pi)?""512Mi"Soft limit for the total size* of files in the cache directory.
+This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+*this is the file size, not the space physically occupied on the disk.
+file-count-limit-percent-if-deleting"{integer}%""70%"If file-count-soft-limit is exceeded and the cache worker performs the cleanup task,
+then the worker will delete some cache files, so after the task,
+the file count should not exceed
+file-count-soft-limit * file-count-limit-percent-if-deleting.
This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+files-total-size-limit-percent-if-deleting"{integer}%""70%"If files-total-size-soft-limit is exceeded and cache worker performs the cleanup task,
+then the worker will delete some cache files, so after the task,
+the files total size should not exceed
+files-total-size-soft-limit * files-total-size-limit-percent-if-deleting.
This doesn't include files with metadata. +To learn more, please refer to the cache system section.
+This is an implementation detail and might change in the future. +Information provided here is meant to help understanding the big picture +and configuring the cache.
+There are two main components - the cache system and the cache worker.
+Handles GET and UPDATE cache requests.
+baseline-compression-level, then writes the data to the disk.In case of successful handling of a request, it notifies the cache worker about this
+event using the queue.
+The queue has a limited size of worker-event-queue-size. If it is full, it will drop
+new events until the cache worker pops some event from the queue.
The cache worker runs in a single thread with lower priority and pops events from the queue +in a loop handling them one by one.
+Read the statistics file for the cache file, +increase the usage counter and write it back to the disk.
+Attempt recompressing the cache file if all of the following conditions are met:
+optimized-compression-usage-counter-threshold,optimized-compression-level,optimizing-compression-task-timeout interval.When recompressing, optimized-compression-level is used as a compression level.
cleanup-interval.
+During this task:
+file-count-soft-limit or files-total-size-soft-limit is exceeded,
+then recognized files will be deleted according to
+file-count-limit-percent-if-deleting and files-total-size-limit-percent-if-deleting.
+Wasmtime uses Least Recently Used (LRU) cache replacement policy and requires that
+the filesystem maintains proper mtime (modification time) of the files.
+Files with future mtimes are treated specially - more details
+in allowed-clock-drift-for-files-from-future.The Rust Programming Language supports WebAssembly
+as a compilation target. If you're not familiar with Rust it's recommended to
+start with its introductory documentation.
+Compiling to WebAssembly will involve specifying the desired target via the
+--target flag, and to do this there are a number of "target triples" for
+WebAssembly compilation in Rust:
wasm32-wasi - when using wasmtime this is likely what you'll be using. The
+WASI target is integrated into the standard library and is intended on
+producing standalone binaries.wasm32-unknown-unknown - this target, like the WASI one, is focused on
+producing single *.wasm binaries. The standard library, however, is largely
+stubbed out since the "unknown" part of the target means libstd can't assume
+anything. This means that while binaries will likely work in wasmtime,
+common conveniences like println! or panic! won't work.wasm32-unknown-emscripten - this target is intended to work in a web browser
+and produces a *.wasm file coupled with a *.js file, and it is not
+compatible with wasmtime.For the rest of this documentation we'll assume that you're using the
+wasm32-wasi target for compiling Rust code and executing inside of wasmtime.
Cross-compiling to WebAssembly involves a number of knobs that need
+configuration, but you can often gloss over these internal details by using
+build tooling intended for the WASI target. For example we can start out writing
+a WebAssembly binary with cargo wasi.
First up we'll install cargo wasi:
$ cargo install cargo-wasi
+Next we'll make a new Cargo project:
+$ cargo new hello-world
+$ cd hello-world
+Inside of src/main.rs you'll see the canonical Rust "Hello, World!" using
+println!. We'll be executing this for the wasm32-wasi target, so you'll want
+to make sure you're previously built wasmtime and inserted it into
+PATH;
$ cargo wasi run
+info: downloading component 'rust-std' for 'wasm32-wasi'
+info: installing component 'rust-std' for 'wasm32-wasi'
+ Compiling hello-world v0.1.0 (/hello-world)
+ Finished dev [unoptimized + debuginfo] target(s) in 0.16s
+ Running `/.cargo/bin/cargo-wasi target/wasm32-wasi/debug/hello-world.wasm`
+ Running `target/wasm32-wasi/debug/hello-world.wasm`
+Hello, world!
+And we're already running our first WebAssembly code inside of wasmtime!
While it's automatically happening for you as part of cargo wasi, you can also
+run wasmtime yourself:
$ wasmtime target/wasm32-wasi/debug/hello-world.wasm
+Hello, world!
+You can check out the introductory documentation of
+cargo-wasi as
+well for some more information.
Previously for "Hello, World!" we created a binary project which used
+src/main.rs. Not all *.wasm binaries are intended to be executed like
+commands, though. Some are intended to be loaded into applications and called
+through various APIs, acting more like libraries. For this use case you'll want
+to add this to Cargo.toml:
# in Cargo.toml ...
+
+[lib]
+crate-type = ['cdylib']
+and afterwards you'll want to write your code in src/lib.rs like so:
++# #![allow(unused_variables)] +#fn main() { +#[no_mangle] +pub extern "C" fn print_hello() { + println!("Hello, world!"); +} +#}
When you execute cargo wasi build that'll generate a *.wasm file which has
+one exported function, print_hello. We can then run it via the CLI like so:
$ cargo wasi build
+ Compiling hello-world v0.1.0 (/home/alex/code/hello-world)
+ Finished dev [unoptimized + debuginfo] target(s) in 0.08s
+$ wasmtime --invoke print_hello target/wasm32-wasi/debug/hello_world.wasm
+Hello, world!
+As a library crate one of your primary consumers may be other languages as well.
+You'll want to consult the section of this book for using wasmtime from
+Python` and after running through the basics there you can
+execute our file in Python:
$ cp target/wasm32-wasi/debug/hello_world.wasm .
+$ python3
+>>> import wasmtime
+>>> import hello_world
+>>> hello_world.print_hello()
+Hello, world!
+()
+>>>
+Note that this form of using #[no_mangle] Rust functions is pretty primitive.
+You're only able to work with primitive datatypes like integers and floats.
+While this works for some applications if you need to work with richer types
+like strings or structs, then you'll want to use the support in wasmtime for
+interface types.
Working with WebAssembly modules at the bare-bones level means that you're only
+dealing with integers and floats. Many APIs, however, want to work with things
+like byte arrays, strings, structures, etc. To facilitate these interactions the
+WebAssembly Interface Types
+Proposal comes into play. The
+wasmtime runtime has support for interface types, and the Rust toolchain has
+library support in a crate called
+wasm-bindgen.
++Note: WebAssembly Interface Types is still a WebAssembly proposal and is +under active development. The toolchain may not match the exact specification, +and during development you'll generally need to make sure tool versions are +all kept up to date to ensure everything aligns right. This'll all smooth over +as the proposal stabilizes!
+
To get started with WebAssembly interface types let's write a library +module which will generate a greeting for us. The module itself won't do any +printing, we'll simply be working with some strings.
+To get starts let's add this to our Cargo.toml:
[lib]
+crate-type = ['cdylib']
+
+[dependencies]
+wasm-bindgen = "0.2.54"
+Using this crate, we can then update our src/lib.rs with the following:
++# #![allow(unused_variables)] +#fn main() { +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub fn greet(name: &str) -> String { + format!("Hello, {}!", name) +} +#}
Then we can build this with:
+$ cargo wasi build --release
+ Updating crates.io index
+...
+ Finished dev [unoptimized + debuginfo] target(s) in 9.57s
+ Downloading precompiled wasm-bindgen v0.2.54
+and we have our new wasm binary!
+++Note: for now when using
+wasm-bindgenyou must use--releasemode to +build wasi binaries with interface types.
We can then test out support for this with the CLI:
+$ wasmtime --invoke greet ./target/wasm32-wasi/release/hello_world.wasm "wasmtime CLI"
+warning: using `--invoke` with a function that takes arguments is experimental and may break in the future
+warning: using `--invoke` with a function that returns values is experimental and may break in the future
+Hello, wasmtime CLI!
+Here we can see some experimental warnings, but we got our error message printed
+out! The first CLI parameter, "wasmtime CLI", was passed as the first argument
+of the greet function. The resulting string was then printed out to the
+console.
Like before, we can also execute this with Python:
+$ cp target/wasm32-wasi/release/hello_world.wasm .
+$ python3
+>>> import wasmtime
+>>> import hello_world
+>>> hello_world.greet('python interpreter')
+'Hello, python interpreter!'
+>>>
+Note that wasm-bindgen was originally developed for JS and usage in a browser,
+but a subset of its implementation (such as arguments which are strings) are
+supported for WebAssembly interface types. You can also check out the reference
+documentation for wasm-bindgen for
+more information about how it works. Note that the wasm-bindgen support for
+wasm interface type is still in its nascent phase and is likely to be greatly
+improved in the future.
Currently only Rust functions can be exported from a wasm module. Rust functions
+must be #[no_mangle] to show up in the final binary, but if you're using
+#[wasm_bindgen] that will happen automatically for you.
Memory is by default exported from Rust modules under the name memory. This
+can be tweaked with the -Clink-arg flag to rustc to pass flags to LLD, the
+WebAssembly code linker.
Tables cannot be imported at this time. When using rustc directly there is no
+support for anyref and only one function table is supported. When using
+wasm-bindgen it may inject an anyref table if necessary, but this table is
+an internal detail and is not exported. The function table can be exported by
+passing the --export-table argument to LLD (via -C link-arg) or can be
+imported with the --import-table.
Rust currently does not have support for exporting or importing custom global
+values.
Only functions can be imported in Rust at this time, and they can be imported +via raw interfaces like:
+++# #![allow(unused_variables)] +#fn main() { +#[link(wasm_import_module = "the-wasm-import-module")] +extern "C" { + // imports the name `foo` from `the-wasm-import-module` + fn foo(); + + // functions can have integer/float arguments/return values + fn translate(a: i32) -> f32; + + // Note that the ABI of Rust and wasm is somewhat in flux, so while this + // works, it's recommended to rely on raw integer/float values where + // possible. + fn translate_fancy(my_struct: MyStruct) -> u32; + + // you can also explicitly specify the name to import, this imports `bar` + // instead of `baz` from `the-wasm-import-module`. + #[link_name = "bar"] + fn baz(); +} +#}
When you're using wasm-bindgen you would instead use:
++# #![allow(unused_variables)] +#fn main() { +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(module = "the-wasm-import-module")] +extern "C" { + fn foo(); + fn baz(); + // ... +} +#}
Note that unless you're using interface types you likely don't need
+wasm-bindgen.
... more coming soon
+This document shows how to embed Wasmtime using the Rust API, and run a simple +wasm program.
+Let's create a simple WebAssembly file with a single exported function that returns an integer:
+(;; wat2wasm hello.wat -o $WASM_FILES/hello.wasm ;;)
+(module
+ (func (export "answer") (result i32)
+ i32.const 42
+ )
+)
+$ cargo new --bin wasmtime_hello
+$ cd wasmtime_hello
+$ cp $WASM_FILES/hello.wasm .
+We will be using the wasmtime engine/API to run the wasm file, so we will add the dependency to Cargo.toml:
[dependencies]
+wasmtime = "<current version>"
+where "wasmtime crate.
It is time to add code to the src/main.rs. First, storage needs to be activated:
++# #![allow(unused_variables)] +#fn main() { +use wasmtime::*; + +let store = Store::default(); +#}
The HostRef will be used a lot -- it is a "convenience" object to store and refer an object between the host and
+the embedded environments.
The hello.wasm can be read from the file system and provided to the Module object constructor as &[u8]:
++# #![allow(unused_variables)] +#fn main() { +use std::fs::read; + +let hello_wasm = read("hello.wasm").expect("wasm file"); + +let module = HostRef::new(Module::new(&store, &hello_wasm).expect("wasm module")); +#}
The module instance can now be created. Normally, you would provide exports, but in this case, there are none required:
+++# #![allow(unused_variables)] +#fn main() { +let instance = Instance::new(&store, &module, &[]).expect("wasm instance"); +#}
Everything is set. If a WebAssembly module has a start function -- it was run. +The instance's exports can be used at this point. wasmtime provides functions +to look up an export by name, and ensure that it's a function:
+++# #![allow(unused_variables)] +#fn main() { +let answer = instance.find_export_by_name("answer").expect("answer").func().expect("function"); +#}
The exported function can be called using the call method. Remember that in most of the cases,
+a HostRef<_> object will be returned, so borrow() or borrow_mut() method has to be used to refer the
+specific object. The exported "answer" function accepts no parameters and returns a single i32 value.
++# #![allow(unused_variables)] +#fn main() { +let result = answer.borrow().call(&[]).expect("success"); +println!("Answer: {}", result[0].i32()); +#}
The names of the WebAssembly module's imports and exports can be discovered by means of module's corresponding methods.
++use std::fs::read; +use wasmtime::*; + +fn main() { + let store = Store::default(); + + let wasm = read("hello.wasm").expect("wasm file"); + + let module = HostRef::new(Module::new(&store, &wasm).expect("wasm module")); + let instance = Instance::new(&store, &module, &[]).expect("wasm instance"); + + let answer = instance.find_export_by_name("answer").expect("answer").func().expect("function"); + let result = answer.borrow().call(&[]).expect("success"); + println!("Answer: {}", result[0].i32()); +} +
... more coming soon
+... more coming soon
+... more coming soon
+The wasmtime project is a configurable and lightweight runtime for WebAssembly
+which has a number of ways it can be configured. Not all features are supported
+on all platforms, but it is intended that wasmtime can run in some capacity on
+almost all platforms! The matrix of what's being tested, what works, and what's
+supported where is evolving over time, and this document hopes to capture a
+snapshot of what the current state of the world looks like.
All features of wasmtime should work on the following platforms:
For more detailed information about supported platforms, please check out the +sections below!
+The JIT compiler, backed by either lightbeam or cranelift supports only the
+x86_64 architecture at this time. Support for at least ARM, AArch64, and x86 is
+planned at this time.
Usage of the JIT compiler will require a host operating system which supports
+creating executable memory pages on-the-fly. In Rust terms this generally means
+that std needs to be supported on this platform.
At this time wasmtime does not have a mode in which it simply interprets
+WebAssembly code. It is planned to add support for an interpreter, however, and
+this will have minimal system dependencies. It is planned that the system will
+need to support some form of dynamic memory allocation, but other than that not
+much else will be needed.
#[no_std]?The wasmtime project does not currently use #[no_std] for its crates, but
+this is not because it won't support it! At this time we're still gathering use
+cases for for what #[no_std] might entail, so if you're interested in this
+we'd love to hear about your use case! Feel free to open an issue on the
+wasmtime repository to discuss this.
... more coming soon
+... more coming soon
+... more coming soon
+We're excited to work on Wasmtime together with you! This guide should help you +get up and running with Wasmtime development. But first, make sure you've read +the Code of Conduct!
+We chat about Wasmtime development on Gitter — join +us!
+If you're having trouble building Wasmtime, aren't sure why a test is failing, +or have any other questions, feel free to ask here. You can also open an +issue!
+If you're looking for something to do, these are great places to start:
+Issues labeled "good first +issue" +— these issues tend to be simple, what needs to be done is well known, +and are good for new contributors to tackle. The goal is to learn Wasmtime's +development workflow and make sure that you can build and test Wasmtime.
+Issues labeled "help +wanted" +— these are issues that we need a little help with!
+If you're unsure if an issue is a good fit for you or not, feel free to ask in a +comment on the issue, or in chat.
+This section describes everything required to build and run Wasmtime.
+Before we can actually build Wasmtime, we'll need to make sure these things are +installed first.
+Install the Rust toolchain here. This
+includes rustup, cargo, rustc, etc...
libclang (optional)The wasmtime-fuzzing crate transitively depends on bindgen, which requires
+that your system has a libclang installed. Therefore, if you want to hack on
+Wasmtime's fuzzing infrastructure, you'll need libclang. Details on how to
+get libclang and make it available for bindgen are
+here.
wasmtime CLITo make an unoptimized, debug build of the wasmtime CLI tool, go to the root
+of the repository and run this command:
cargo build
+The built executable will be located at target/debug/wasmtime.
To make an optimized build, run this command in the root of the repository:
+cargo build --release
+The built executable will be located at target/release/wasmtime.
You can also build and run a local wasmtime CLI by replacing cargo build
+with cargo run.
You can build any of the Wasmtime crates by appending -p wasmtime-whatever to
+the cargo build invocation. For example, to build the wasmtime-jit crate,
+execute this command:
cargo build -p wasmtime-jit
+Alternatively, you can cd into the crate's directory, and run cargo build
+there, without needing to supply the -p flag:
cd crates/jit/
+cargo build
+This section describes how to run Wasmtime's tests and add new tests.
+Before continuing, make sure you can build +Wasmtime successfully. Can't run the tests if you +can't build it!
+To run all of Wasmtime's tests (excluding WASI integration tests), execute this command:
+cargo test --all
+To include WASI integration tests, you'll need wasm32-wasi target installed, which,
+assuming you're using rustup.rs to manage your Rust versions,
+can be done as follows:
rustup target add wasm32-wasi
+Next, to run all tests including the WASI integration tests, execute this command:
+cargo test --features test_programs --all
+You can also exclude a particular crate from testing with --exclude. For
+example, if you want to avoid testing the wastime-fuzzing crate — which
+requires that libclang is installed on your system, and for some reason maybe
+you don't have it — you can run:
cargo test --all --exclude wasmtime-fuzzing
+You can test a particular Wasmtime crate with cargo test -p wasmtime-whatever. For example, to test the wasmtime-environ crate, execute
+this command:
cargo test -p wasmtime-environ
+Alternatively, you can cd into the crate's directory, and run cargo test
+there, without needing to supply the -p flag:
cd crates/environ/
+cargo test
+The spec testsuite itself is in a git submodule, so make sure you've +checked it out and initialized its submodule:
+git submodule update --init
+When the submodule is checked out, Wasmtime runs the Wasm spec testsuite as part
+of testing the wasmtime-cli crate:
cargo test -p wasmtime-cli
+WASI integration tests can be run separately from all other tests which
+can be useful when working on the wasi-common crate. This can be done by
+executing this command:
cargo test --features test_programs -p test-programs
+#[test]-Style TestsFor very "unit-y" tests, we add test modules in the same .rs file as the
+code that is being tested. These test modules are configured to only get
+compiled during testing with #[cfg(test)].
++# #![allow(unused_variables)] +#fn main() { +// some code... + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn some_test_for_that_code() { + // ... + } +} +#}
If you're writing a unit test and a test module doesn't already exist, you can
+create one.
For more "integration-y" tests, we create a tests directory within the crate,
+and put the tests inside there. For example, there are various code
+cache-related tests at crates/environ/tests/cache_*.rs. Always feel free to
+add a tests directory to a crate, if you want to add a new test and there
+aren't any existing tests.
We use the spec testsuite as-is and without custom patches or a forked +version. This probably isn't what you want to modify when adding a new Wasmtime +test!
+When you have a Wasmtime-specific test that you'd like to write in Wast and use
+the Wast-style assertions, you can add it to our "misc testsuite". The misc
+testsuite uses the same syntax and assertions as the spec testsuite, but lives
+in tests/misc_testsuite. Feel free to add new tests to existing
+tests/misc_testsuite/*.wast files or create new ones as needed. These tests
+are run as part of the wasmtime-cli crate's tests.
If you have a new test that you think really belongs in the spec testsuite, make +sure it makes sense for every Wasm implementation to run your test (i.e. it +isn't Wasmtime-specific) and send a pull request +upstream. Once it is accepted in +the upstream repo, we can update our git submodule and we'll start running the +new tests.
+When you have a WASI-specific test program that you'd like to include as a
+test case to run against our WASI implementation, you can add it to our
+test-programs crate. In particular, you should drop a main-style Rust source
+file into crates/test-programs/wasi-tests/src/bin/some_new_test.rs with a
+name of your choice. And that's it! The build script included in the
+test-programs crate will automatically generate the necessary boilerplate
+code for your test program so that it's run on all supported hosts.
If you would like to tweak which host to run the test program against however
+(for instance, only on Unix but on Windows), you can tweak that in the build
+script located under crates/test-programs/build.rs.
Test case generators and oracles live in the wasmtime-fuzzing crate, located
+in the crates/fuzzing directory.
A test case generator takes raw, unstructured input from a fuzzer and +translates that into a test case. This might involve interpreting the raw input +as "DNA" or pre-determined choices through a decision tree and using it to +generate an in-memory data structure, or it might be a no-op where we interpret +the raw bytes as if they were Wasm.
+An oracle takes a test case and determines whether we have a bug. For example, +one of the simplest oracles is to take a Wasm binary as an input test case, +validate and instantiate it, and (implicitly) check that no assertions failed or +segfaults happened. A more complicated oracle might compare the result of +executing a Wasm file with and without optimizations enabled, and make sure that +the two executions are observably identical.
+Our test case generators and oracles strive to be fuzzer-agnostic: they can be +reused with libFuzzer or AFL or any other fuzzing engine or driver.
+cargo fuzz Fuzz TargetsWe combine a test case generator and one more more oracles into a fuzz +target. Because the target needs to pipe the raw input from a fuzzer into the +test case generator, it is specific to a particular fuzzer. This is generally +fine, since they're only a couple of lines of glue code.
+Currently, all of our fuzz targets are written for
+libFuzzer and cargo fuzz. They are defined in
+the fuzz subdirectory.
See
+fuzz/README.md
+for details on how to run these fuzz targets and set up a corpus of seed inputs.
... more coming soon
+... more coming soon
+Note: this Code of Conduct pertains to individuals' behavior. Please also see the Organizational Code of Conduct.
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+Examples of behavior that contributes to creating a positive environment include:
+Examples of unacceptable behavior by participants include:
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the Bytecode Alliance CoC team at report@bytecodealliance.org. The CoC team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The CoC team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the Bytecode Alliance's leadership.
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at http://contributor-covenant.org/version/1/4
+ +... more coming soon
+ +... more coming soon
+ +... more coming soon
+ +The wasmtime project is a configurable and lightweight runtime for WebAssembly
+which has a number of ways it can be configured. Not all features are supported
+on all platforms, but it is intended that wasmtime can run in some capacity on
+almost all platforms! The matrix of what's being tested, what works, and what's
+supported where is evolving over time, and this document hopes to capture a
+snapshot of what the current state of the world looks like.
All features of wasmtime should work on the following platforms:
For more detailed information about supported platforms, please check out the +sections below!
+The JIT compiler, backed by either lightbeam or cranelift supports only the
+x86_64 architecture at this time. Support for at least ARM, AArch64, and x86 is
+planned at this time.
Usage of the JIT compiler will require a host operating system which supports
+creating executable memory pages on-the-fly. In Rust terms this generally means
+that std needs to be supported on this platform.
At this time wasmtime does not have a mode in which it simply interprets
+WebAssembly code. It is planned to add support for an interpreter, however, and
+this will have minimal system dependencies. It is planned that the system will
+need to support some form of dynamic memory allocation, but other than that not
+much else will be needed.
#[no_std]?The wasmtime project does not currently use #[no_std] for its crates, but
+this is not because it won't support it! At this time we're still gathering use
+cases for for what #[no_std] might entail, so if you're interested in this
+we'd love to hear about your use case! Feel free to open an issue on the
+wasmtime repository to discuss this.
... more coming soon
+ +... more coming soon
+ +hello-world.wasm... more coming soon
+ +hello-world.wasm with Wasmtime... more coming soon
+ +... more coming soon
+ +The Rust Programming Language supports WebAssembly
+as a compilation target. If you're not familiar with Rust it's recommended to
+start with its introductory documentation.
+Compiling to WebAssembly will involve specifying the desired target via the
+--target flag, and to do this there are a number of "target triples" for
+WebAssembly compilation in Rust:
wasm32-wasi - when using wasmtime this is likely what you'll be using. The
+WASI target is integrated into the standard library and is intended on
+producing standalone binaries.wasm32-unknown-unknown - this target, like the WASI one, is focused on
+producing single *.wasm binaries. The standard library, however, is largely
+stubbed out since the "unknown" part of the target means libstd can't assume
+anything. This means that while binaries will likely work in wasmtime,
+common conveniences like println! or panic! won't work.wasm32-unknown-emscripten - this target is intended to work in a web browser
+and produces a *.wasm file coupled with a *.js file, and it is not
+compatible with wasmtime.For the rest of this documentation we'll assume that you're using the
+wasm32-wasi target for compiling Rust code and executing inside of wasmtime.
Cross-compiling to WebAssembly involves a number of knobs that need
+configuration, but you can often gloss over these internal details by using
+build tooling intended for the WASI target. For example we can start out writing
+a WebAssembly binary with cargo wasi.
First up we'll install cargo wasi:
$ cargo install cargo-wasi
+Next we'll make a new Cargo project:
+$ cargo new hello-world
+$ cd hello-world
+Inside of src/main.rs you'll see the canonical Rust "Hello, World!" using
+println!. We'll be executing this for the wasm32-wasi target, so you'll want
+to make sure you're previously built wasmtime and inserted it into
+PATH;
$ cargo wasi run
+info: downloading component 'rust-std' for 'wasm32-wasi'
+info: installing component 'rust-std' for 'wasm32-wasi'
+ Compiling hello-world v0.1.0 (/hello-world)
+ Finished dev [unoptimized + debuginfo] target(s) in 0.16s
+ Running `/.cargo/bin/cargo-wasi target/wasm32-wasi/debug/hello-world.wasm`
+ Running `target/wasm32-wasi/debug/hello-world.wasm`
+Hello, world!
+And we're already running our first WebAssembly code inside of wasmtime!
While it's automatically happening for you as part of cargo wasi, you can also
+run wasmtime yourself:
$ wasmtime target/wasm32-wasi/debug/hello-world.wasm
+Hello, world!
+You can check out the introductory documentation of
+cargo-wasi as
+well for some more information.
Previously for "Hello, World!" we created a binary project which used
+src/main.rs. Not all *.wasm binaries are intended to be executed like
+commands, though. Some are intended to be loaded into applications and called
+through various APIs, acting more like libraries. For this use case you'll want
+to add this to Cargo.toml:
# in Cargo.toml ...
+
+[lib]
+crate-type = ['cdylib']
+and afterwards you'll want to write your code in src/lib.rs like so:
++# #![allow(unused_variables)] +#fn main() { +#[no_mangle] +pub extern "C" fn print_hello() { + println!("Hello, world!"); +} +#}
When you execute cargo wasi build that'll generate a *.wasm file which has
+one exported function, print_hello. We can then run it via the CLI like so:
$ cargo wasi build
+ Compiling hello-world v0.1.0 (/home/alex/code/hello-world)
+ Finished dev [unoptimized + debuginfo] target(s) in 0.08s
+$ wasmtime --invoke print_hello target/wasm32-wasi/debug/hello_world.wasm
+Hello, world!
+As a library crate one of your primary consumers may be other languages as well.
+You'll want to consult the section of this book for using wasmtime from
+Python` and after running through the basics there you can
+execute our file in Python:
$ cp target/wasm32-wasi/debug/hello_world.wasm .
+$ python3
+>>> import wasmtime
+>>> import hello_world
+>>> hello_world.print_hello()
+Hello, world!
+()
+>>>
+Note that this form of using #[no_mangle] Rust functions is pretty primitive.
+You're only able to work with primitive datatypes like integers and floats.
+While this works for some applications if you need to work with richer types
+like strings or structs, then you'll want to use the support in wasmtime for
+interface types.
Working with WebAssembly modules at the bare-bones level means that you're only
+dealing with integers and floats. Many APIs, however, want to work with things
+like byte arrays, strings, structures, etc. To facilitate these interactions the
+WebAssembly Interface Types
+Proposal comes into play. The
+wasmtime runtime has support for interface types, and the Rust toolchain has
+library support in a crate called
+wasm-bindgen.
++Note: WebAssembly Interface Types is still a WebAssembly proposal and is +under active development. The toolchain may not match the exact specification, +and during development you'll generally need to make sure tool versions are +all kept up to date to ensure everything aligns right. This'll all smooth over +as the proposal stabilizes!
+
To get started with WebAssembly interface types let's write a library +module which will generate a greeting for us. The module itself won't do any +printing, we'll simply be working with some strings.
+To get starts let's add this to our Cargo.toml:
[lib]
+crate-type = ['cdylib']
+
+[dependencies]
+wasm-bindgen = "0.2.54"
+Using this crate, we can then update our src/lib.rs with the following:
++# #![allow(unused_variables)] +#fn main() { +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub fn greet(name: &str) -> String { + format!("Hello, {}!", name) +} +#}
Then we can build this with:
+$ cargo wasi build --release
+ Updating crates.io index
+...
+ Finished dev [unoptimized + debuginfo] target(s) in 9.57s
+ Downloading precompiled wasm-bindgen v0.2.54
+and we have our new wasm binary!
+++Note: for now when using
+wasm-bindgenyou must use--releasemode to +build wasi binaries with interface types.
We can then test out support for this with the CLI:
+$ wasmtime --invoke greet ./target/wasm32-wasi/release/hello_world.wasm "wasmtime CLI"
+warning: using `--invoke` with a function that takes arguments is experimental and may break in the future
+warning: using `--invoke` with a function that returns values is experimental and may break in the future
+Hello, wasmtime CLI!
+Here we can see some experimental warnings, but we got our error message printed
+out! The first CLI parameter, "wasmtime CLI", was passed as the first argument
+of the greet function. The resulting string was then printed out to the
+console.
Like before, we can also execute this with Python:
+$ cp target/wasm32-wasi/release/hello_world.wasm .
+$ python3
+>>> import wasmtime
+>>> import hello_world
+>>> hello_world.greet('python interpreter')
+'Hello, python interpreter!'
+>>>
+Note that wasm-bindgen was originally developed for JS and usage in a browser,
+but a subset of its implementation (such as arguments which are strings) are
+supported for WebAssembly interface types. You can also check out the reference
+documentation for wasm-bindgen for
+more information about how it works. Note that the wasm-bindgen support for
+wasm interface type is still in its nascent phase and is likely to be greatly
+improved in the future.
Currently only Rust functions can be exported from a wasm module. Rust functions
+must be #[no_mangle] to show up in the final binary, but if you're using
+#[wasm_bindgen] that will happen automatically for you.
Memory is by default exported from Rust modules under the name memory. This
+can be tweaked with the -Clink-arg flag to rustc to pass flags to LLD, the
+WebAssembly code linker.
Tables cannot be imported at this time. When using rustc directly there is no
+support for anyref and only one function table is supported. When using
+wasm-bindgen it may inject an anyref table if necessary, but this table is
+an internal detail and is not exported. The function table can be exported by
+passing the --export-table argument to LLD (via -C link-arg) or can be
+imported with the --import-table.
Rust currently does not have support for exporting or importing custom global
+values.
Only functions can be imported in Rust at this time, and they can be imported +via raw interfaces like:
+++# #![allow(unused_variables)] +#fn main() { +#[link(wasm_import_module = "the-wasm-import-module")] +extern "C" { + // imports the name `foo` from `the-wasm-import-module` + fn foo(); + + // functions can have integer/float arguments/return values + fn translate(a: i32) -> f32; + + // Note that the ABI of Rust and wasm is somewhat in flux, so while this + // works, it's recommended to rely on raw integer/float values where + // possible. + fn translate_fancy(my_struct: MyStruct) -> u32; + + // you can also explicitly specify the name to import, this imports `bar` + // instead of `baz` from `the-wasm-import-module`. + #[link_name = "bar"] + fn baz(); +} +#}
When you're using wasm-bindgen you would instead use:
++# #![allow(unused_variables)] +#fn main() { +use wasm_bindgen::prelude::*; + +#[wasm_bindgen(module = "the-wasm-import-module")] +extern "C" { + fn foo(); + fn baz(); + // ... +} +#}
Note that unless you're using interface types you likely don't need
+wasm-bindgen.