Remove dependency on TargetIsa from Wasmtime crates (#3178)

This commit started off by deleting the `cranelift_codegen::settings`
reexport in the `wasmtime-environ` crate and then basically played
whack-a-mole until everything compiled again. The main result of this is
that the `wasmtime-*` family of crates have generally less of a
dependency on the `TargetIsa` trait and type from Cranelift. While the
dependency isn't entirely severed yet this is at least a significant
start.

This commit is intended to be largely refactorings, no functional
changes are intended here. The refactorings are:

* A `CompilerBuilder` trait has been added to `wasmtime_environ` which
  server as an abstraction used to create compilers and configure them
  in a uniform fashion. The `wasmtime::Config` type now uses this
  instead of cranelift-specific settings. The `wasmtime-jit` crate
  exports the ability to create a compiler builder from a
  `CompilationStrategy`, which only works for Cranelift right now. In a
  cranelift-less build of Wasmtime this is expected to return a trait
  object that fails all requests to compile.

* The `Compiler` trait in the `wasmtime_environ` crate has been souped
  up with a number of methods that Wasmtime and other crates needed.

* The `wasmtime-debug` crate is now moved entirely behind the
  `wasmtime-cranelift` crate.

* The `wasmtime-cranelift` crate is now only depended on by the
  `wasmtime-jit` crate.

* Wasm types in `cranelift-wasm` no longer contain their IR type,
  instead they only contain the `WasmType`. This is required to get
  everything to align correctly but will also be required in a future
  refactoring where the types used by `cranelift-wasm` will be extracted
  to a separate crate.

* I moved around a fair bit of code in `wasmtime-cranelift`.

* Some gdb-specific jit-specific code has moved from `wasmtime-debug` to
  `wasmtime-jit`.

crates/jit/src/instantiate.rs

@@ -5,6 +5,7 @@
 
 use crate::code_memory::CodeMemory;
 use crate::compiler::{Compilation, Compiler};
+use crate::debug::create_gdbjit_image;
 use crate::link::link_module;
 use crate::object::ObjectUnwindInfo;
 use anyhow::{Context, Result};
@@ -13,9 +14,7 @@ use serde::{Deserialize, Serialize};
 use std::ops::Range;
 use std::sync::Arc;
 use thiserror::Error;
-use wasmtime_debug::create_gdbjit_image;
 use wasmtime_environ::entity::PrimaryMap;
-use wasmtime_environ::isa::TargetIsa;
 use wasmtime_environ::wasm::{
     DefinedFuncIndex, InstanceTypeIndex, ModuleTypeIndex, SignatureIndex, WasmFuncType,
 };
@@ -103,13 +102,10 @@ impl CompilationArtifacts {
         data: &[u8],
         use_paged_mem_init: bool,
     ) -> Result<(usize, Vec<CompilationArtifacts>, TypeTables), SetupError> {
-        let (main_module, translations, types) = ModuleEnvironment::new(
-            compiler.frontend_config(),
-            compiler.tunables(),
-            compiler.features(),
-        )
-        .translate(data)
-        .map_err(|error| SetupError::Compile(CompileError::Wasm(error)))?;
+        let (main_module, translations, types) =
+            ModuleEnvironment::new(compiler.tunables(), compiler.features())
+                .translate(data)
+                .map_err(|error| SetupError::Compile(CompileError::Wasm(error)))?;
 
         let list = compiler.run_maybe_parallel::<_, _, SetupError, _>(
             translations,
@@ -225,25 +221,24 @@ impl CompiledModule {
     /// artifacts.
     pub fn from_artifacts_list(
         artifacts: Vec<CompilationArtifacts>,
-        isa: &dyn TargetIsa,
-        profiler: &dyn ProfilingAgent,
         compiler: &Compiler,
+        profiler: &dyn ProfilingAgent,
     ) -> Result<Vec<Arc<Self>>, SetupError> {
         compiler.run_maybe_parallel(artifacts, |a| {
-            CompiledModule::from_artifacts(a, isa, profiler)
+            CompiledModule::from_artifacts(a, compiler, profiler)
         })
     }
 
     /// Creates `CompiledModule` directly from `CompilationArtifacts`.
     pub fn from_artifacts(
         artifacts: CompilationArtifacts,
-        isa: &dyn TargetIsa,
+        compiler: &Compiler,
         profiler: &dyn ProfilingAgent,
     ) -> Result<Arc<Self>, SetupError> {
         // Allocate all of the compiled functions into executable memory,
         // copying over their contents.
         let (code_memory, code_range, finished_functions, trampolines) = build_code_memory(
-            isa,
+            compiler,
             &artifacts.obj,
             &artifacts.module,
             &artifacts.unwind_info,
@@ -480,7 +475,7 @@ fn create_dbg_image(
 }
 
 fn build_code_memory(
-    isa: &dyn TargetIsa,
+    compiler: &Compiler,
     obj: &[u8],
     module: &Module,
     unwind_info: &[ObjectUnwindInfo],
@@ -531,7 +526,7 @@ fn build_code_memory(
     let code_range = (code_range.as_ptr(), code_range.len());
 
     // Make all code compiled thus far executable.
-    code_memory.publish(isa);
+    code_memory.publish(compiler);
 
     Ok((code_memory, code_range, finished_functions, trampolines))
 }