diff --git a/lib/cretonne/src/ir/function.rs b/lib/cretonne/src/ir/function.rs
index b1ae83dc28..b0115a70e3 100644
--- a/lib/cretonne/src/ir/function.rs
+++ b/lib/cretonne/src/ir/function.rs
@@ -64,11 +64,6 @@ impl Function {
     pub fn new() -> Function {
         Self::with_name_signature(FunctionName::default(), Signature::new())
     }
-
-    /// Get the signature of this function.
-    pub fn own_signature(&self) -> &Signature {
-        &self.signature
-    }
 }
 
 impl Display for Function {
diff --git a/lib/cretonne/src/isa/mod.rs b/lib/cretonne/src/isa/mod.rs
index af689a3947..37684addb1 100644
--- a/lib/cretonne/src/isa/mod.rs
+++ b/lib/cretonne/src/isa/mod.rs
@@ -45,7 +45,7 @@ pub use isa::registers::{RegInfo, RegUnit, RegClass, RegClassIndex};
 pub use isa::constraints::{RecipeConstraints, OperandConstraint, ConstraintKind};
 
 use settings;
-use ir::{InstructionData, DataFlowGraph};
+use ir::{InstructionData, DataFlowGraph, Signature};
 
 pub mod riscv;
 pub mod intel;
@@ -161,4 +161,24 @@ pub trait TargetIsa {
             recipe_names: self.recipe_names(),
         }
     }
+
+    /// Legalize a function signature.
+    ///
+    /// This is used to legalize both the signature of the function being compiled and any called
+    /// functions. The signature should be modified by adding `ArgumentLoc` annotations to all
+    /// arguments and return values.
+    ///
+    /// Arguments with types that are not supported by the ABI can be expanded into multiple
+    /// arguments:
+    ///
+    /// - Integer types that are too large to fit in a register can be broken into multiple
+    ///   arguments of a smaller integer type.
+    /// - Floating point types can be bit-cast to an integer type of the same size, and possible
+    ///   broken into smaller integer types.
+    /// - Vector types can be bit-cast and broken down into smaller vectors or scalars.
+    ///
+    /// The legalizer will adapt argument and return values as necessary at all ABI boundaries.
+    fn legalize_signature(&self, _sig: &mut Signature) {
+        unimplemented!()
+    }
 }
diff --git a/lib/cretonne/src/isa/riscv/abi.rs b/lib/cretonne/src/isa/riscv/abi.rs
new file mode 100644
index 0000000000..7025bf8c0e
--- /dev/null
+++ b/lib/cretonne/src/isa/riscv/abi.rs
@@ -0,0 +1,12 @@
+//! RISC-V ABI implementation.
+//!
+//! This module implements the RISC-V calling convention through the primary `legalize_signature()`
+//! entry point.
+
+use ir::Signature;
+use settings as shared_settings;
+
+/// Legalize `sig` for RISC-V.
+pub fn legalize_signature(_sig: &mut Signature, _flags: &shared_settings::Flags) {
+    // TODO: Actually do something.
+}
diff --git a/lib/cretonne/src/isa/riscv/mod.rs b/lib/cretonne/src/isa/riscv/mod.rs
index 8b27a46119..220f062278 100644
--- a/lib/cretonne/src/isa/riscv/mod.rs
+++ b/lib/cretonne/src/isa/riscv/mod.rs
@@ -1,6 +1,7 @@
 //! RISC-V Instruction Set Architecture.
 
 pub mod settings;
+mod abi;
 mod enc_tables;
 mod registers;
 
@@ -8,7 +9,7 @@ use super::super::settings as shared_settings;
 use isa::enc_tables::{self as shared_enc_tables, lookup_enclist, general_encoding};
 use isa::Builder as IsaBuilder;
 use isa::{TargetIsa, RegInfo, Encoding, Legalize, RecipeConstraints};
-use ir::{InstructionData, DataFlowGraph};
+use ir::{InstructionData, DataFlowGraph, Signature};
 
 #[allow(dead_code)]
 struct Isa {
@@ -74,6 +75,11 @@ impl TargetIsa for Isa {
     fn recipe_constraints(&self) -> &'static [RecipeConstraints] {
         &enc_tables::RECIPE_CONSTRAINTS
     }
+
+    fn legalize_signature(&self, sig: &mut Signature) {
+        // We can pass in `self.isa_flags` too, if we need it.
+        abi::legalize_signature(sig, &self.shared_flags)
+    }
 }
 
 #[cfg(test)]
diff --git a/lib/cretonne/src/legalizer.rs b/lib/cretonne/src/legalizer.rs
index 015bfb9b30..3d57c73b95 100644
--- a/lib/cretonne/src/legalizer.rs
+++ b/lib/cretonne/src/legalizer.rs
@@ -23,6 +23,8 @@ use isa::{TargetIsa, Legalize};
 /// - Fill out `func.encodings`.
 ///
 pub fn legalize_function(func: &mut Function, isa: &TargetIsa) {
+    legalize_signatures(func, isa);
+
     // TODO: This is very simplified and incomplete.
     func.encodings.resize(func.dfg.num_insts());
     let mut pos = Cursor::new(&mut func.layout);
@@ -74,3 +76,15 @@ pub fn legalize_function(func: &mut Function, isa: &TargetIsa) {
 //
 // Concretely, this defines private functions `narrow()`, and `expand()`.
 include!(concat!(env!("OUT_DIR"), "/legalizer.rs"));
+
+/// Legalize all the function signatures in `func`.
+///
+/// This changes all signatures to be ABI-compliant with full `ArgumentLoc` annotations. It doesn't
+/// change the entry block arguments, calls, or return instructions, so this can leave the function
+/// in a state with type discrepancies.
+fn legalize_signatures(func: &mut Function, isa: &TargetIsa) {
+    isa.legalize_signature(&mut func.signature);
+    for sig in func.dfg.signatures.keys() {
+        isa.legalize_signature(&mut func.dfg.signatures[sig]);
+    }
+}