Sto lavorando al tutorial su LLVM in Rust ora. Ho già implementato alcune parti di Kaleidoscope REPL. Ha funzionato bene per me, ma all'improvviso ha smesso di funzionare e ogni tentativo di calcolare un valore termina in LLVM ERROR: Target does not support MC emission! ora. Sembra che sia successo dopo l'aggiornamento del compilatore di Rust all'ultima notte (ma non sono sicuro che sia qui).Quale può essere la ragione di `LLVM ERRORE: Target non supporta l'emissione MC!`?
Seguono pezzi di codice rilevanti. funzione
inizializzazione:
#[allow(non_snake_case)]
pub unsafe fn LLVMInitializeNativeTarget() {
llvm::LLVMInitializeX86TargetInfo();
llvm::LLVMInitializeX86Target();
llvm::LLVMInitializeX86TargetMC();
}
creazione Modulo: creazione
let module = llvm::LLVMModuleCreateWithNameInContext(module_name.to_c_str().as_ptr(), context);
Esecuzione motore:
let mut exec_engine = 0 as llvm::ExecutionEngineRef;
let mut error = 0 as *const c_char;
LLVMCreateExecutionEngineForModule(&mut exec_engine, module, &mut error);
assert!(exec_engine != 0 as llvm::ExecutionEngineRef);
compilazione e l'esecuzione della funzione:
pub fn run(value: llvm::ValueRef, context: &Context) -> f64 {
unsafe {
let result = LLVMRunFunction(context.exec_engine,
value,
0,
0 as *const GenericValueRef);
let ty = llvm::LLVMDoubleTypeInContext(context.context);
LLVMGenericValueToFloat(ty, result)
}
}
Funzioni LLVM prefissate da llvm :: vengono importate da rustc, quelle non prefissate da llvm :: vengono importate dal mio codice, vedere https://github.com/jauhien/iron-kaleidoscope/blob/master/src/missing_llvm_bindings/mod.rs.
Per vedere elenco completo di codice, guardo https://github.com/jauhien/iron-kaleidoscope/blob/master/src/builder.rs
Sto usando l'ultimo Rust notte e LLVM 3.5.0.
UPD: Dopo aver commentato la chiamata a LLVMInitializeNativeTarget, JIT ha iniziato a lavorare di nuovo. Ma mi sto ancora chiedendo quale sia la ragione del problema e come JIT dovrebbe essere usato correttamente.
UPD2: dopo aver commentato la riga con l'inizializzazione, non tutto ha ripreso a funzionare: le chiamate alla funzione definita nel codice Rust non riescono con LLVM ERROR: Tried to execute an unknown external function ora.
Funzione Sto cercando di chiamare (questo ha funzionato in precedenza): sessione
#[no_mangle]
pub extern fn print(x: f64) -> f64 {
println!("> {} <", x);
x
}
Esempio:
[email protected] iron-repl % ./target/iron_kaleidoscope
>extern print(x)
declare double @print(double)
>print(1)
LLVM ERROR: Tried to execute an unknown external function: print
Non sicuro se è la causa del tuo problema, ma 'module_name.to_c_str(). As_ptr()' non è sicuro memoria. Non stai garantendo che la stringa C sopravviva al puntatore. Vedi i [documenti] (http://doc.rust-lang.org/std/str/trait.StrSlice.html#tymethod.as_ptr). Raccomando invece di usare ['with_c_str'] (http://doc.rust-lang.org/std/c_str/trait.ToCStr.html#tymethod.with_c_str). – Dylan
Inoltre, consiglio di evitare l'API LLVM esistente in Rust. È basato sull'API LLVM C, che non è supportato come l'API C++ ed è completamente "non sicuro". Scoprirai anche che mancano alcune parti dell'API. Per un progetto a cui sto lavorando, sto costruendo i miei binding sicuri per le classi/funzioni C++. Non è così difficile, e il risultato finale è molto più facile da usare. – Dylan
Ho saputo, ma quello è un tutorial. Quindi uso ciò che è già disponibile. Se esistesse qualche API sicura, la userei. Che dire di 'with_c_str' Non vedo alcun motivo per usarlo qui.Oppure la stringa può essere deallocata prima della funzione in cui è passata come viene chiamato il parametro? Ad ogni modo, non ha niente a che fare con il mio problema. –