Lines Matching full:operand
171 /// operand with '*'. This is equivalent to printing '*' then using
173 void writeOperandDeref(Value *Operand) {
174 if (isAddressExposed(Operand)) {
176 writeOperandInternal(Operand);
179 writeOperand(Operand);
184 void writeOperand(Value *Operand, bool Static = false);
186 void writeOperandInternal(Value *Operand, bool Static = false);
187 void writeOperandWithCast(Value* Operand, unsigned Opcode);
188 void writeOperandWithCast(Value* Operand, const ICmpInst &I);
191 void writeMemoryAccess(Value *Operand, Type *OperandType,
342 std::string GetValueName(const Value *Operand);
1174 // Print a constant assuming that it is the operand for a given Opcode. The
1179 // Extract the operand's type, we'll need it.
1187 // the new type to which the operand should be casted by setting the value
1213 // operand.
1224 std::string CWriter::GetValueName(const Value *Operand) {
1227 if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(Operand)) {
1229 Operand = V;
1233 if (const GlobalValue *GV = dyn_cast<GlobalValue>(Operand)) {
1239 std::string Name = Operand->getName();
1242 unsigned &No = AnonValueNumbers[Operand];
1301 void CWriter::writeOperandInternal(Value *Operand, bool Static) {
1302 if (Instruction *I = dyn_cast<Instruction>(Operand))
1311 Constant* CPV = dyn_cast<Constant>(Operand);
1316 Out << GetValueName(Operand);
1319 void CWriter::writeOperand(Value *Operand, bool Static) {
1320 bool isAddressImplicit = isAddressExposed(Operand);
1324 writeOperandInternal(Operand, Static);
1361 // Write the operand with a cast to another type based on the Opcode being used.
1364 void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
1366 // Extract the operand's type, we'll need it.
1367 Type* OpTy = Operand->getType();
1375 // Based on the Opcode for which this Operand is being written, determine
1376 // the new type to which the operand should be casted by setting the value
1402 // Write out the casted operand if we should, otherwise just write the
1403 // operand.
1408 writeOperand(Operand);
1411 writeOperand(Operand);
1414 // Write the operand with a cast to another type based on the icmp predicate
1416 void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) {
1417 // This has to do a cast to ensure the operand has the right signedness.
1418 // Also, if the operand is a pointer, we make sure to cast to an integer when
1424 // Write out the casted operand if we should, otherwise just write the
1425 // operand.
1427 writeOperand(Operand);
1434 // If the operand was a pointer, convert to a large integer type.
1435 Type* OpTy = Operand->getType();
1437 Operand->getContext());
1442 writeOperand(Operand);
2550 // Certain instructions require the operand to be forced to a specific type
2552 // below for operand 1
2599 // Certain icmp predicate require the operand to be forced to a specific type
2601 // below for operand 1
2661 // Write the first operand
2664 // Write the second operand
2714 // Make sure we really get a trunc to bool by anding the operand with 1
3385 // Okay, emit the first operand. If Ptr is something that is already address
3390 // If we didn't already emit the first operand, see if we can print it as
3430 void CWriter::writeMemoryAccess(Value *Operand, Type *OperandType,
3451 writeOperand(Operand);
3470 Value *Operand = I.getOperand(0);
3472 if (IntegerType* ITy = dyn_cast<IntegerType>(Operand->getType()))
3479 writeOperand(Operand);
3514 // We know that our operand is not inlined.
