Force casting a Value*

I am trying to cast a Value* irrespective of its underlying subclass to uint64 and pass it on to a method as an argument.

if (StoreInst store_inst = dyn_cast(&I)) {
Value
vo = store_inst->getValueOperand();
uint64 value = /* cast vo to unsigned int 64 bit */
func(value);
}

How can I force cast ‘vo’ to unsigned int?

Sounds like you’re looking for reinterpret_cast: http://en.cppreference.com/w/cpp/language/reinterpret_cast

Sounds like you're looking for reinterpret_cast: http://en.
cppreference.com/w/cpp/language/reinterpret_cast

I tried cast<ConstInt>(vo), but that failed at run-time.

Sounds like you're looking for reinterpret_cast: http://en.cp
preference.com/w/cpp/language/reinterpret_cast

I tried cast<ConstInt>(vo), but that failed at run-time.

That is not the same as reinterpret_cast<int64>(some_value_star).

Or better yet, reinterpret_cast<intptr_t>(some_value_star)

http://www.cplusplus.com/reference/cstdint/

Cheers,

  -- nikodemus

Sounds like you're looking for reinterpret_cast: http://en.cp
preference.com/w/cpp/language/reinterpret_cast

I tried cast<ConstInt>(vo), but that failed at run-time.

That is not the same as reinterpret_cast<int64>(some_value_star).

None of the following work.

Value* var_value = reinterpret_cast<intptr_t>(vo);
Value* var_value= reinterpret_cast<uint64_t>(vo);

The following worked, still didn't solve the problem:

Value* var_value = reinterpret_cast<ConstantInt*>(vo);

I can't pass var_value to a function accepting uint64_t. LLVM complains
about broken function call.

Well, yes. var_value has type "ConstantInt *", not uint64_t. Assuming
the value being stored actually is a constant known at compile-time
you should be able to use cast<ConstantInt *>(vo)->getZExtValue() to
retrieve a uint64_t value (careful of i128s!).

If that cast fails then you're not dealing with a constant store. This
is either a nuisance (if you were expecting the possibility and can
deal with it) or a huge misunderstanding over compile-time vs runtime
values.

If it's a nuisance, you can use "dyn_cast" instead of "cast". That'll
return nullptr if the store wasn't a constant instead of crashing; you
can decide what to do at that point.

Cheers.

Tim.

I think it's a misunderstanding in may part. Let me explain my intention
first. I want to retrieve the value (if isPointerTy() returns true) to be
stored by a store instruction at run-time and pass on that value as either
an unsigned int (64) or a pointer (char*) to an external function. The call
to that function is inserted using IRBuilder.CreateCall().

Consider the code snippet below.

Assuming you know it’s a 64 bit value, and the function you are calling takes a uint64_t, try this:

Value* args[] = {store_inst->getOperand(0)};

Assuming you know it's a 64 bit value, and the function you are calling
takes a uint64_t, try this:

The values from the test program are of type: i32/i32*/i32**. Can't I
interpret these as uint64_t some way?

Sure, you can call store_inst->getOperand(0)->getType(), and call different functions based on the type, e.g., foo_8, foo_16, foo_32, etc…

Here’s an example of how you could do it: https://github.com/donhinton/CVRFI/blob/master/lib/pass/Node.cpp#L224

Sure, you can call store_inst->getOperand(0)->getType(), and call
different functions based on the type, e.g., foo_8, foo_16, foo_32, etc...

Here's an example of how you could do it: https://github.com/
donhinton/CVRFI/blob/master/lib/pass/Node.cpp#L224

You are dispatching call to different functions depending on if it's a
LoadInst/StoreInst/CallInst. I am using a similar structure in my project,
too. However, irrespective of the Type of the argument (i.e.
i32/i32*/i32**), I just need its value (store_inst->getValueOperand() which
is the same as store_inst->getOperand(0)). I want to ignore the type in
this case. I feel there should be some unified means to deal all the cases
in a single function. If I treat all the point values as uint64_t, that
should solve the problem. But, I am scratching my head since last one day
to figure out how to convince LLVM ignore the pointer type and just pass on
its value as an unsigned, 64 bit integer.

You are dispatching call to different functions depending on if it's a
LoadInst/StoreInst/CallInst. I am using a similar structure in my project,
too. However, irrespective of the Type of the argument (i.e.
i32/i32*/i32**), I just need its value (store_inst->getValueOperand() which
is the same as store_inst->getOperand(0)).

Since you're after the runtime value you're going to have to convert
whatever you get to an i64 (and hope/verify that that's how a uint64_t
actually gets passed; a good bet, but not guaranteed).

So if you're storing a pointer you're going to have to insert a
ptrtoint instruction and then a call instruction using that result; if
you're storing an i32 you're going to have to insert a zext followed
by the call, etc. If you're storing an i128 or a 128-bit vector,
you're screwed.

I want to ignore the type in this case. I feel there should be some unified means to deal all the cases in a
single function.

There isn't, because it's rarely actually useful; the type is
important. The closest thing is IRBuilder::CreateZExtOrTrunc which
will handle integer types in many cases, but not pointers or vectors
or structs or arrays or ...

Tim.