Method object

crates/environ/src/compile/mod.rs:319–361

Creates a new `Object` file which is used to build the results of a compilation into. The returned object file will have an appropriate architecture/endianness for `self.triple()`, but at this time it is always an ELF file, regardless of target platform.

(&self, kind: ObjectKind)

    /// architecture/endianness for `self.triple()`, but at this time it is
    /// always an ELF file, regardless of target platform.
    fn object(&self, kind: ObjectKind) -> Result<Object<'static>> {
        use target_lexicon::Architecture::*;

        let triple = self.triple();
        let (arch, flags) = match triple.architecture {
            X86_32(_) => (Architecture::I386, 0),
            X86_64 => (Architecture::X86_64, 0),
            Arm(_) => (Architecture::Arm, 0),
            Aarch64(_) => (Architecture::Aarch64, 0),
            S390x => (Architecture::S390x, 0),
            Riscv64(_) => (Architecture::Riscv64, 0),
            // XXX: the `object` crate won't successfully build an object
            // with relocations and such if it doesn't know the
            // architecture, so just pretend we are riscv64. Yolo!
            //
            // Also note that we add some flags to `e_flags` in the object file
            // to indicate that it's pulley, not actually riscv64. This is used
            // by `wasmtime objdump` for example.
            Pulley32 | Pulley32be => (Architecture::Riscv64, obj::EF_WASMTIME_PULLEY32),
            Pulley64 | Pulley64be => (Architecture::Riscv64, obj::EF_WASMTIME_PULLEY64),
            architecture => {
                bail!("target architecture {architecture:?} is unsupported");
            }
        };
        let mut obj = Object::new(
            BinaryFormat::Elf,
            arch,
            match triple.endianness().unwrap() {
                target_lexicon::Endianness::Little => object::Endianness::Little,
                target_lexicon::Endianness::Big => object::Endianness::Big,
            },
        );
        obj.flags = FileFlags::Elf {
            os_abi: obj::ELFOSABI_WASMTIME,
            e_flags: flags
                | match kind {
                    ObjectKind::Module => obj::EF_WASMTIME_MODULE,
                    ObjectKind::Component => obj::EF_WASMTIME_COMPONENT,
                },
            abi_version: 0,
        };
        Ok(obj)
    }

    /// Returns the target triple that this compiler is compiling for.
    fn triple(&self) -> &target_lexicon::Triple;