Que retourne CallInst :: Create() dans LLVM?

Question

Considérant

static CallInst *Create(Value *Func, 
         ArrayRef<Value *> Args, 
         const Twine &NameStr = "", 
         Instruction *InsertBefore = 0) 

cette fonction, je me demande ce que la valeur de retour de cette fonction moyens.

Par exemple, dans le code suivant,

int foo(int a); 
... 
Function *foo_ptr = ~~;//say, foo is refered through getOrInsertFunction() 
CallInst *ptr = CallInst::Create(foo_ptr, .../* properly set */); 

le CallInst * ptr est la valeur de retour. De manière abstraite, est-ce que ptr signifie

1. une valeur entière renvoyée par int foo (int);
2. ou CALL instruction

Je pensais que le numéro 2 était la réponse, mais il a commencé à se confondre regardant certains codes.

Answer 1

Les deux valeurs 1 et 2 sont "vraies". Il renvoie l'instruction d'appel, dont la "valeur", lorsque nous exécutons le code, sera la valeur de retour de la fonction.

Pour illustrer, prendre ce petit programme Pascal:

program p; 

function f: integer; 
begin 
    f := 42; 
end; { f } 

begin 
    writeln(f); 
end. 

Ce qui se traduit par ce LLVM-IR:

; ModuleID = 'TheModule' 
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 
target triple = "x86_64-unknown-linux-gnu" 

%text = type { i32, i8*, i32, i32 } 

@input = global %text zeroinitializer, align 8 
@output = global %text zeroinitializer, align 8 
@UnitIniList = constant [1 x i8*] zeroinitializer 

define i32 @P.f() #0 { 
entry: 
    %f = alloca i32, align 4 
    store i32 42, i32* %f 
    %0 = load i32, i32* %f 
    ret i32 %0 
} 

define void @__PascalMain() #0 { 
entry: 
    %calltmp = call i32 @P.f() 
    call void @__write_int(%text* @output, i32 %calltmp, i32 0) 
    call void @__write_nl(%text* @output) 
    ret void 
} 

declare void @__write_int(%text*, i32, i32) 

declare void @__write_nl(%text*) 

attributes #0 = { "no-frame-pointer-elim"="true" } 

Le call i32 @P.f() est généré par:

inst = builder.CreateCall(calleF, argsV, "calltmp"); 

Le contenu de inst est %calltmp = call i32 @P.f() - et c'est un CallInst 'valeur'.

et inst est renvoyé à l'évaluation de l'expression pour l'argument writeln.