[WIP] Module API (#294)

* Initial skeleton.

* Add basic faerie support.

This adds enough functionality to enable simple .o file writing through
faerie. This included adding the functionality to Module to support
RelocSink implementations.

* Add basic SimpleJIT support.

This adds enough functionality to enable a simple program to be jitted
and executed.

* Make declare_func_in_func take a Function instead of a Context.

It only needs the Function, and sometimes it's useful to call it from
places that don't have a full Context.

* Temporarily disable local and exported global variables in the Faerie backend.

Faerie assumes these variables use pc-relative offset instructions, and
Cretonne is not yet emitting those instructions.

* FaerieBackend depends on PIC.

Faerie itself only supports PIC objects for now, so add an assert to
Cretonne to check that it's using a PIC target flag.

* SimpleJIT support for data objects.

* Preliminary faerie support for data objects.

* Support for data objects in faerie using the new colocated flag.

* Unit tests for DataContext and friends.

* Add a Module::consume() function.

This consumes the Module and returns the contained Backend, so that
users can call Backend-specific functions with it. For example, the
Faerie backend has functions to write an object file.

* Update the new crates to version 0.4.4.

* Make FaerieBackend own its TargetIsa.

This simplifies its interface, as it eliminates a lifetime parameter.
While we may eventually want to look into allowing multiple clients to
share a TargetIsa, it isn't worth the complexity for FaerieBackend
right now.

* Don't try to protect faerie from multiple declarations.

Let faerie decide for itself whether it wants to consider two
declarations to be compatible.

* Use debug_assert_eq rather than debug_assert with ==.

* Fix FaerieRelocSink's reloc_external to handle data object names.

* Relax the asserts in get_function_definition and get_data_definition.

These functions don't require definable symbols, but they do require
that definable symbols be defined. This is needed for the simplejit
backend.

* Add a function to the faerie backend to retrieve the artifact name.

* Sync up with cretonne changes.

lib/codegen/src/binemit/mod.rs

@@ -23,7 +23,7 @@ pub type CodeOffset = u32;
 pub type Addend = i64;
 
 /// Relocation kinds for every ISA
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum Reloc {
     /// absolute 4-byte
     Abs4,

lib/codegen/src/ir/extfunc.rs

@@ -19,7 +19,7 @@ use std::vec::Vec;
 ///
 /// A signature can optionally include ISA-specific ABI information which specifies exactly how
 /// arguments and return values are passed.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Signature {
     /// The arguments passed to the function.
     pub params: Vec<AbiParam>,
@@ -123,7 +123,7 @@ impl fmt::Display for Signature {
 ///
 /// This describes the value type being passed to or from a function along with flags that affect
 /// how the argument is passed.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AbiParam {
     /// Type of the argument value.
     pub value_type: Type,
@@ -225,7 +225,7 @@ impl fmt::Display for AbiParam {
 ///
 /// On some architectures, small integer function arguments are extended to the width of a
 /// general-purpose register.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum ArgumentExtension {
     /// No extension, high bits are indeterminate.
     None,
@@ -242,7 +242,7 @@ pub enum ArgumentExtension {
 /// frame pointers and callee-saved registers.
 ///
 /// The argument purpose is used to indicate any special meaning of an argument or return value.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum ArgumentPurpose {
     /// A normal user program value passed to or from a function.
     Normal,
@@ -348,7 +348,7 @@ impl fmt::Display for ExtFuncData {
 /// and how stack frames are managed. Since all of these details depend on both the instruction set
 /// architecture and possibly the operating system, a function's calling convention is only fully
 /// determined by a `(TargetIsa, CallConv)` tuple.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum CallConv {
     /// The System V-style calling convention.
     ///

lib/codegen/src/ir/valueloc.rs

@@ -95,7 +95,7 @@ impl<'a> fmt::Display for DisplayValueLoc<'a> {
 ///   outgoing arguments.
 /// - For register arguments, there is usually no difference, but if we ever add support for a
 ///   register-window ISA like SPARC, register arguments would also need to be translated.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub enum ArgumentLoc {
     /// This argument has not been assigned to a location yet.
     Unassigned,