I have a question about inserting instructions into the LLVM IR. I can insert instructions, but my operands do not have the right type, so it fails an assertion at runtime.
I am trying to insert an immediate load instructions, as a means of claiming a new register.
Here is what I do:
Builder.SetInsertPoint(LLVMBB, I);
// The following line looks to me like it would have a chance o! f loading either
// address 5, or else immediate value 5. Unfortunately, it does neither. It compiles
// but crashes at runtime, that the type of the operand is incompatible
Instruction *newI=Builder.CreateLoad(5,“”);
// I also tested this, just to do a little sanity check. It also compiles then
// crashes, for the obvious reason that the operand is a register, but an address
// or an immediate value is expected.
//Instruction *newI=Builder.CreateLoad(I->getOperand(1),“”); // also wrong
So to say it simply, my question is, “How can I create a new Value*, which indicates
an immediate value, such as immediate value 5?”
Thank you for your assistance,
Kao Chang
You should use a constant instead of a load:
Constant *C = ConstantInt::get(Type::Int32Ty, 5);
Note that the constant is not an instruction, but it can be used like
any other Value*.
Best regards,
--Edwin
If you want an immediate constant value, ConstantInt::get(APInt(32, 5, false)) will perhaps help you ?
Olivier.
2009/5/5 seventh moon <suigintou_@hotmail.com>
seventh moon wrote:
[snip]
So to say it simply, my question is, "How can I create a new Value*, which indicates
an immediate value, such as immediate value 5?"
I don't know much about LLVM's code generators, but if all you need is
to create a Value * for an immediate constant, you might try using the
ConstantInt::get() method
(http://llvm.org/doxygen/classllvm_1_1ConstantInt.html#77cd822480bc78732c84a9619e49e14a).
A ConstantInt is a subclass of Value, and you can use it to create
constant integer values in the LLVM IR.
-- John T.
Thank you for your answer. But there is still a problem.
You seem correct about how to define a constant operand. So I added it into my code, like so:
Builder.SetInsertPoint(LLVMBB, I);
Constant *C = ConstantInt::get(APInt(32, 5, false));
Instruction *newI=Builder.Create! Load(C,“”);
It compiles. But it still aborts at runtime with a complaint that the type is not right.
This leads me to think that immediate loads are not generated with the CreateLoad
instruction?
Another person’s reply to my question indicated that a way to avoid inserting the
immediate load entirely; but that is also not what I want, because my explicit purpose
in inserting this load is to claim a register.
Thank you,
Thank you for your answer. But there is still a problem.
You seem correct about how to define a constant operand. So I added it into
my code, like so:
Builder.SetInsertPoint(LLVMBB, I);
Constant *C = ConstantInt::get(APInt(32, 5, false));
Instruction *newI=Builder.Create! Load(C,"");
It compiles. But it still aborts at runtime with a complaint that the type
is not right.
This leads me to think that immediate loads are not generated with the
CreateLoad
instruction?
Correct. Immediates are already Value*s in LLVM IR; you don't have to
load them. You may want to read http://llvm.org/docs/LangRef.html for
descriptions of the instructions and the arguments they take. And
http://llvm.org/docs/ProgrammersManual.html#Value for a description of
the Value class.
Another person's reply to my question indicated that a way to avoid
inserting the
immediate load entirely; but that is also not what I want, because my
explicit purpose
in inserting this load is to claim a register.
I'd bet that's not actually your purpose. Why do you think you need to
claim a register? Note that LLVM pseudo-registers (the things
Instructions define) are not at all the same as machine registers.
If you really want an Instruction, you can bitcast the constant to its
original type. So:
new BitCastInst(ConstantInt::get(Type::Int32Ty, 5), Type::Int32Ty, I);
Don't use the IRBuilder to create the BitCast because it'll
constant-fold it into a ConstantExpr, which isn't an Instruction.
Jeffrey