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`.

cranelift/wasm/src/sections_translator.rs

@@ -10,9 +10,8 @@
 use crate::environ::{Alias, ModuleEnvironment, WasmError, WasmResult};
 use crate::state::ModuleTranslationState;
 use crate::translation_utils::{
-    tabletype_to_type, type_to_type, DataIndex, ElemIndex, EntityIndex, EntityType, FuncIndex,
-    Global, GlobalIndex, GlobalInit, InstanceIndex, Memory, MemoryIndex, ModuleIndex, Table,
-    TableElementType, TableIndex, Tag, TagIndex, TypeIndex,
+    DataIndex, ElemIndex, EntityIndex, EntityType, FuncIndex, Global, GlobalIndex, GlobalInit,
+    InstanceIndex, Memory, MemoryIndex, ModuleIndex, Table, TableIndex, Tag, TagIndex, TypeIndex,
 };
 use crate::wasm_unsupported;
 use core::convert::TryFrom;
@@ -46,10 +45,8 @@ fn entity_type(
         }
         ImportSectionEntryType::Memory(ty) => EntityType::Memory(memory(ty)),
         ImportSectionEntryType::Tag(t) => EntityType::Tag(tag(t)),
-        ImportSectionEntryType::Global(ty) => {
-            EntityType::Global(global(ty, environ, GlobalInit::Import)?)
-        }
-        ImportSectionEntryType::Table(ty) => EntityType::Table(table(ty, environ)?),
+        ImportSectionEntryType::Global(ty) => EntityType::Global(global(ty, GlobalInit::Import)?),
+        ImportSectionEntryType::Table(ty) => EntityType::Table(table(ty)?),
     })
 }
 
@@ -68,26 +65,17 @@ fn tag(e: TagType) -> Tag {
     }
 }
 
-fn table(ty: TableType, environ: &mut dyn ModuleEnvironment<'_>) -> WasmResult<Table> {
+fn table(ty: TableType) -> WasmResult<Table> {
     Ok(Table {
         wasm_ty: ty.element_type.try_into()?,
-        ty: match tabletype_to_type(ty.element_type, environ)? {
-            Some(t) => TableElementType::Val(t),
-            None => TableElementType::Func,
-        },
         minimum: ty.initial,
         maximum: ty.maximum,
     })
 }
 
-fn global(
-    ty: GlobalType,
-    environ: &mut dyn ModuleEnvironment<'_>,
-    initializer: GlobalInit,
-) -> WasmResult<Global> {
+fn global(ty: GlobalType, initializer: GlobalInit) -> WasmResult<Global> {
     Ok(Global {
         wasm_ty: ty.content_type.try_into()?,
-        ty: type_to_type(ty.content_type, environ).unwrap(),
         mutability: ty.mutable,
         initializer,
     })
@@ -175,11 +163,11 @@ pub fn parse_import_section<'data>(
                 environ.declare_tag_import(tag(e), import.module, import.field)?;
             }
             ImportSectionEntryType::Global(ty) => {
-                let ty = global(ty, environ, GlobalInit::Import)?;
+                let ty = global(ty, GlobalInit::Import)?;
                 environ.declare_global_import(ty, import.module, import.field)?;
             }
             ImportSectionEntryType::Table(ty) => {
-                let ty = table(ty, environ)?;
+                let ty = table(ty)?;
                 environ.declare_table_import(ty, import.module, import.field)?;
             }
         }
@@ -218,7 +206,7 @@ pub fn parse_table_section(
     environ.reserve_tables(tables.get_count())?;
 
     for entry in tables {
-        let ty = table(entry?, environ)?;
+        let ty = table(entry?)?;
         environ.declare_table(ty)?;
     }
 
@@ -287,7 +275,7 @@ pub fn parse_global_section(
                 ));
             }
         };
-        let ty = global(ty, environ, initializer)?;
+        let ty = global(ty, initializer)?;
         environ.declare_global(ty)?;
     }