LLVM Instruction Operands

Hello all:

I apologize for what I imagine is a rather silly question, but I'm still
somewhat new to LLVM and am stuck. I am reworking some code that was
originally in the backend involving MachineInstructions and
MachineOperands, and I now need for it to function as an LLVM IR pass,
using just Instructions, etc, and nothing related to 'Machine'.

However, I am not sure how to get the information I need at the IR level.
I need to iterate over all operands of an instruction, analyzing each
operand to get a register number (if available), see if the operand is a
register or an immediate, get the operand def, and some other stuff. I
also need to be able to do implicitDef/Use determination on instructions.
I don't see a way to do this at present.

So, any guidance would be much appreciated.

Thanks!
Griffin Wright

LLVM IR operands *are* other instructions. For example, if you want
to use the result of a multiply in an add, the operand of the add is
simply a pointer to the multiply instruction. This is possible
because the IR is always in SSA form, so there is only one def.

Reid

If your pass really needs to analyze the use of physical registers and
whether individual machine instructions are using immediate operands
or not, then it needs to stay at the machine level. If you only really care
about higher-level things like (1) what operation is being performed,
(2) whether particular operands are constant or not, and (3) if not, how
and when they were produced, then it's far better to work on LLVM IR.

On IR, you test for specific kinds of values using isa or dyn_cast.
For example, I can check whether a value is a 'mul' instruction:
  if (BinaryOperator *op = dyn_cast<BinaryOperator>(val)) {
    if (op->getOpcode() == Instruction::Mul) {
and now I can check whether the LHS is a call:
      if (isa<CallInst>(op->getOperand(0))) {
etc.

John.

That is very helpful, John, thank you. Reid as well, your response cleared
some things up :slight_smile:

Part <n> of my question series:

Say I have a bunch of defs that I'm iterating through, and I want to find
the uses for each def. How should I have my parameters set up? Right now
I'm trying to use the following, where "defs" is defined in the header file
as "std::vector<Instruction*> defs":

for (std::vector<Instruction*>::iterator def_iter = defs.begin();
def_iter!= defs.end(); def_iter++) {
  Instruction* defInsn = dyn_cast<Instruction>(*def_iter);
  for (Instruction::use_iterator use_iter = defInsn->use_begin();
use_iter!= defInsn->use_end(); use_iter++) {
            Instruction *pUseInstr = dyn_cast<Instruction>(*use_iter);
            Do stuff with the newly found use instruction!
            }
}

I feel like having the use_begin() based on defInsn is grossly incorrect
(and the rest of the code here might be as well), so I was hoping to run it
past someone with [much] more knowledge than I.

Thanks again for tolerating a poor newbie's questions.

-Griffin

Hello all:

I apologize for what I imagine is a rather silly question, but I'm still
somewhat new to LLVM and am stuck. I am reworking some code that was
originally in the backend involving MachineInstructions and
MachineOperands, and I now need for it to function as an LLVM IR pass,
using just Instructions, etc, and nothing related to 'Machine'.

However, I am not sure how to get the information I need at the IR

level.

I need to iterate over all operands of an instruction, analyzing each
operand to get a register number (if available), see if the operand is a
register or an immediate, get the operand def, and some other stuff. I
also need to be able to do implicitDef/Use determination on

instructions.