Baby steps

The current changes allow me to compile the Solidity program below, and
the resulting wasm file passes `cargo stylus --check`.

```sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
}
```

Author: smoelius

src/codegen/dispatch/polkadot.rs

@@ -69,7 +69,7 @@ pub(crate) fn function_dispatch(
     ]
 }
 
-struct Dispatch<'a> {
+pub(super) struct Dispatch<'a> {
     start: usize,
     input_len: usize,
     input_ptr: Expression,
@@ -110,7 +110,7 @@ impl<'a> Dispatch<'a> {
     /// Create a new `Dispatch` struct that has all the data needed for building the dispatch logic.
     ///
     /// `ty` specifies whether to include constructors or functions.
-    fn new(
+    pub(super) fn new(
         all_cfg: &'a [ControlFlowGraph],
         ns: &'a mut Namespace,
         opt: &'a Options,
@@ -195,7 +195,7 @@ impl<'a> Dispatch<'a> {
     }
 
     /// Build the dispatch logic into the returned control flow graph.
-    fn build(mut self) -> ControlFlowGraph {
+    pub(super) fn build(mut self) -> ControlFlowGraph {
         // Go to fallback or receive if there is no selector in the call input
         let cond = Expression::Less {
             loc: Codegen,

src/codegen/dispatch/stylus.rs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use super::polkadot;
+use crate::{
+    codegen::{cfg::ControlFlowGraph, Options},
+    sema::ast::Namespace,
+};
+use solang_parser::pt::FunctionTy;
+
+pub(crate) fn function_dispatch(
+    _contract_no: usize,
+    all_cfg: &[ControlFlowGraph],
+    ns: &mut Namespace,
+    opt: &Options,
+) -> Vec<ControlFlowGraph> {
+    vec![polkadot::Dispatch::new(all_cfg, ns, opt, FunctionTy::Function).build()]
+}

src/emit/binary.rs

@@ -53,7 +53,10 @@ macro_rules! emit_context {
         #[allow(unused_macros)]
         macro_rules! byte_ptr {
             () => {
-                $binary.context.i8_type().ptr_type(AddressSpace::default())
+                $binary
+                    .context
+                    .i8_type()
+                    .ptr_type(inkwell::AddressSpace::default())
             };
         }
 

src/emit/stylus/mod.rs

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::codegen::dispatch::polkadot::DispatchType;
+use crate::codegen::Options;
+use crate::emit::functions::emit_functions;
+use crate::emit::Binary;
+use crate::emit_context;
+use crate::sema::ast::{Contract, Namespace};
+use inkwell::context::Context;
+use inkwell::module::{Linkage, Module};
+use inkwell::values::{BasicMetadataValueEnum, FunctionValue, IntValue, PointerValue};
+use inkwell::AddressSpace;
+
+mod target;
+
+pub struct StylusTarget;
+
+impl StylusTarget {
+    pub fn build<'a>(
+        context: &'a Context,
+        std_lib: &Module<'a>,
+        contract: &'a Contract,
+        ns: &'a Namespace,
+        opt: &'a Options,
+    ) -> Binary<'a> {
+        let filename = ns.files[contract.loc.file_no()].file_name();
+        let mut binary = Binary::new(
+            context,
+            ns.target,
+            &contract.id.name,
+            filename.as_str(),
+            opt,
+            std_lib,
+            None,
+        );
+
+        let mut target = StylusTarget;
+
+        target.declare_externals(&binary);
+
+        emit_functions(&mut target, &mut binary, contract, ns);
+
+        target.emit_dispatch(&mut binary, ns);
+
+        binary.internalize(&[
+            "log_txt",
+            "msg_reentrant",
+            "msg_value",
+            "pay_for_memory_grow",
+            "read_args",
+            "storage_flush_cache",
+            "storage_cache_bytes32",
+            "storage_load_bytes32",
+            "write_result",
+        ]);
+
+        binary
+    }
+
+    fn public_function_prelude<'a>(
+        &self,
+        binary: &Binary<'a>,
+        function: FunctionValue<'a>,
+    ) -> (PointerValue<'a>, IntValue<'a>) {
+        emit_context!(binary);
+
+        let entry = binary.context.append_basic_block(function, "entry");
+
+        binary.builder.position_at_end(entry);
+
+        // init our heap
+        binary
+            .builder
+            .build_call(
+                binary.module.get_function("__init_heap").unwrap(),
+                &[],
+                "__init_heap",
+            )
+            .unwrap();
+
+        let args_len = function.get_nth_param(0).unwrap();
+
+        let args = call!("__malloc", &[args_len.into()], "__malloc")
+            .try_as_basic_value()
+            .left()
+            .unwrap();
+
+        call!("read_args", &[args.into()], "read_args");
+
+        (args.into_pointer_value(), args_len.into_int_value())
+    }
+
+    fn declare_externals(&self, binary: &Binary) {
+        let ctx = binary.context;
+        let i32_val = ctx.i32_type().into();
+        let u8_ptr = ctx.i8_type().ptr_type(AddressSpace::default()).into();
+
+        macro_rules! external {
+            ($name:literal, $fn_type:ident $(,)? $( $args:expr ),*) => {
+                binary.module.add_function(
+                    $name,
+                    ctx.$fn_type().fn_type(&[$($args),*], false),
+                    Some(Linkage::External),
+                );
+            };
+        }
+
+        external!("log_txt", void_type, u8_ptr, i32_val);
+        external!("msg_reentrant", i32_type);
+        external!("msg_value", void_type, i32_val);
+        external!("pay_for_memory_grow", void_type, i32_val);
+        external!("read_args", void_type, u8_ptr);
+        external!("storage_cache_bytes32", void_type, u8_ptr, u8_ptr);
+        external!("storage_flush_cache", void_type, i32_val);
+        external!("storage_load_bytes32", void_type, u8_ptr, u8_ptr);
+        external!("write_result", void_type, u8_ptr, i32_val);
+    }
+
+    fn emit_dispatch(&mut self, bin: &mut Binary, _ns: &Namespace) {
+        let ty = bin
+            .context
+            .i32_type()
+            .fn_type(&[bin.context.i32_type().into()], false);
+        let func = bin.module.add_function("user_entrypoint", ty, None);
+        let (args, args_len) = self.public_function_prelude(bin, func);
+        // smoelius: FIXME: zero
+        let zero = bin.context.custom_width_int_type(256).const_zero();
+        let args = &[
+            BasicMetadataValueEnum::PointerValue(args),
+            BasicMetadataValueEnum::IntValue(args_len),
+            BasicMetadataValueEnum::IntValue(zero),
+            BasicMetadataValueEnum::PointerValue(bin.selector.as_pointer_value()),
+        ];
+        let dispatch_cfg_name = &DispatchType::Call.to_string();
+        let cfg = bin.module.get_function(dispatch_cfg_name).unwrap();
+        bin.builder
+            .build_call(cfg, args, dispatch_cfg_name)
+            .unwrap();
+
+        bin.builder.build_unreachable().unwrap();
+    }
+}