diff --git a/lib/clif-backend/src/code.rs b/lib/clif-backend/src/code.rs
index 1bd1958e3de..e8f0681d9c6 100644
--- a/lib/clif-backend/src/code.rs
+++ b/lib/clif-backend/src/code.rs
@@ -54,6 +54,10 @@ impl ModuleCodeGenerator<CraneliftFunctionCodeGenerator, Caller, CodegenError>
         }
     }
 
+    fn new_with_target(_: Option<String>, _: Option<String>, _: Option<String>) -> Self {
+        unimplemented!()
+    }
+
     fn backend_id() -> Backend {
         Backend::Cranelift
     }
diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs
index b2f5b62d97a..4eb694b1084 100644
--- a/lib/llvm-backend/src/code.rs
+++ b/lib/llvm-backend/src/code.rs
@@ -7969,24 +7969,37 @@ impl ModuleCodeGenerator<LLVMFunctionCodeGenerator, LLVMBackend, CodegenError>
     for LLVMModuleCodeGenerator
 {
     fn new() -> LLVMModuleCodeGenerator {
+        Self::new_with_target(None, None, None)
+    }
+
+    fn new_with_target(
+        triple: Option<String>,
+        cpu_name: Option<String>,
+        cpu_features: Option<String>,
+    ) -> LLVMModuleCodeGenerator {
         let context = Context::create();
         let module = context.create_module("module");
 
-        Target::initialize_x86(&InitializationConfig {
-            asm_parser: true,
-            asm_printer: true,
-            base: true,
-            disassembler: true,
-            info: true,
-            machine_code: true,
-        });
-        let triple = TargetMachine::get_default_triple().to_string();
+        let triple = triple.unwrap_or(TargetMachine::get_default_triple().to_string());
+
+        match triple {
+            _ if triple.starts_with("x86") => Target::initialize_x86(&InitializationConfig {
+                asm_parser: true,
+                asm_printer: true,
+                base: true,
+                disassembler: true,
+                info: true,
+                machine_code: true,
+            }),
+            _ => unimplemented!(),
+        }
+
         let target = Target::from_triple(&triple).unwrap();
         let target_machine = target
             .create_target_machine(
                 &triple,
-                &TargetMachine::get_host_cpu_name().to_string(),
-                &TargetMachine::get_host_cpu_features().to_string(),
+                &cpu_name.unwrap_or(TargetMachine::get_host_cpu_name().to_string()),
+                &cpu_features.unwrap_or(TargetMachine::get_host_cpu_features().to_string()),
                 OptimizationLevel::Aggressive,
                 RelocMode::Static,
                 CodeModel::Large,
diff --git a/lib/runtime-core/src/backend.rs b/lib/runtime-core/src/backend.rs
index f1086de0d68..893874ed934 100644
--- a/lib/runtime-core/src/backend.rs
+++ b/lib/runtime-core/src/backend.rs
@@ -129,6 +129,11 @@ pub struct CompilerConfig {
     pub enforce_stack_check: bool,
     pub track_state: bool,
     pub features: Features,
+
+    // target info used by LLVM
+    pub triple: Option<String>,
+    pub cpu_name: Option<String>,
+    pub cpu_features: Option<String>,
 }
 
 pub trait Compiler {
diff --git a/lib/runtime-core/src/codegen.rs b/lib/runtime-core/src/codegen.rs
index e96f419e6b4..9e42d80490a 100644
--- a/lib/runtime-core/src/codegen.rs
+++ b/lib/runtime-core/src/codegen.rs
@@ -74,6 +74,13 @@ pub trait ModuleCodeGenerator<FCG: FunctionCodeGenerator<E>, RM: RunnableModule,
     /// Creates a new module code generator.
     fn new() -> Self;
 
+    /// Creates a new module code generator for specified target.
+    fn new_with_target(
+        triple: Option<String>,
+        cpu_name: Option<String>,
+        cpu_features: Option<String>,
+    ) -> Self;
+
     /// Returns the backend id associated with this MCG.
     fn backend_id() -> Backend;
 
@@ -206,7 +213,14 @@ impl<
             validate_with_features(wasm, &compiler_config.features)?;
         }
 
-        let mut mcg = MCG::new();
+        let mut mcg = match MCG::backend_id() {
+            Backend::LLVM => MCG::new_with_target(
+                compiler_config.triple.clone(),
+                compiler_config.cpu_name.clone(),
+                compiler_config.cpu_features.clone(),
+            ),
+            _ => MCG::new(),
+        };
         let mut chain = (self.middleware_chain_generator)();
         let info = crate::parse::read_module(
             wasm,
diff --git a/lib/singlepass-backend/src/codegen_x64.rs b/lib/singlepass-backend/src/codegen_x64.rs
index 7a71a289fe2..0c8f43a9d9a 100644
--- a/lib/singlepass-backend/src/codegen_x64.rs
+++ b/lib/singlepass-backend/src/codegen_x64.rs
@@ -370,6 +370,10 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
         }
     }
 
+    fn new_with_target(_: Option<String>, _: Option<String>, _: Option<String>) -> Self {
+        unimplemented!()
+    }
+
     fn backend_id() -> Backend {
         Backend::Singlepass
     }
diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs
index 6195e60a612..6284865fcc1 100644
--- a/src/bin/wasmer.rs
+++ b/src/bin/wasmer.rs
@@ -443,6 +443,9 @@ fn execute_wasm(options: &Run) -> Result<(), String> {
                     simd: options.features.simd || options.features.all,
                     threads: options.features.threads || options.features.all,
                 },
+                triple: None,
+                cpu_name: None,
+                cpu_features: None,
             },
             &*compiler,
         )