LLDB  mainline
IRInterpreter.cpp
Go to the documentation of this file.
1 //===-- IRInterpreter.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/ModuleSpec.h"
12 #include "lldb/Core/ValueObject.h"
18 #include "lldb/Utility/Endian.h"
19 #include "lldb/Utility/Log.h"
20 #include "lldb/Utility/Scalar.h"
21 #include "lldb/Utility/Status.h"
23 
24 #include "lldb/Target/ABI.h"
26 #include "lldb/Target/Target.h"
27 #include "lldb/Target/Thread.h"
28 #include "lldb/Target/ThreadPlan.h"
30 
31 #include "llvm/IR/Constants.h"
32 #include "llvm/IR/DataLayout.h"
33 #include "llvm/IR/Function.h"
34 #include "llvm/IR/Instructions.h"
35 #include "llvm/IR/Intrinsics.h"
36 #include "llvm/IR/LLVMContext.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/IR/Operator.h"
39 #include "llvm/Support/raw_ostream.h"
40 
41 #include <map>
42 
43 using namespace llvm;
44 
45 static std::string PrintValue(const Value *value, bool truncate = false) {
46  std::string s;
47  raw_string_ostream rso(s);
48  value->print(rso);
49  rso.flush();
50  if (truncate)
51  s.resize(s.length() - 1);
52 
53  size_t offset;
54  while ((offset = s.find('\n')) != s.npos)
55  s.erase(offset, 1);
56  while (s[0] == ' ' || s[0] == '\t')
57  s.erase(0, 1);
58 
59  return s;
60 }
61 
62 static std::string PrintType(const Type *type, bool truncate = false) {
63  std::string s;
64  raw_string_ostream rso(s);
65  type->print(rso);
66  rso.flush();
67  if (truncate)
68  s.resize(s.length() - 1);
69  return s;
70 }
71 
72 static bool CanIgnoreCall(const CallInst *call) {
73  const llvm::Function *called_function = call->getCalledFunction();
74 
75  if (!called_function)
76  return false;
77 
78  if (called_function->isIntrinsic()) {
79  switch (called_function->getIntrinsicID()) {
80  default:
81  break;
82  case llvm::Intrinsic::dbg_declare:
83  case llvm::Intrinsic::dbg_value:
84  return true;
85  }
86  }
87 
88  return false;
89 }
90 
92 public:
93  typedef std::map<const Value *, lldb::addr_t> ValueMap;
94 
96  DataLayout &m_target_data;
98  const BasicBlock *m_bb;
99  const BasicBlock *m_prev_bb;
100  BasicBlock::const_iterator m_ii;
101  BasicBlock::const_iterator m_ie;
102 
104  size_t m_frame_size;
106 
109 
110  InterpreterStackFrame(DataLayout &target_data,
111  lldb_private::IRExecutionUnit &execution_unit,
112  lldb::addr_t stack_frame_bottom,
113  lldb::addr_t stack_frame_top)
114  : m_target_data(target_data), m_execution_unit(execution_unit),
115  m_bb(nullptr), m_prev_bb(nullptr) {
116  m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle
118  m_addr_byte_size = (target_data.getPointerSize(0));
119 
120  m_frame_process_address = stack_frame_bottom;
121  m_frame_size = stack_frame_top - stack_frame_bottom;
122  m_stack_pointer = stack_frame_top;
123  }
124 
126 
127  void Jump(const BasicBlock *bb) {
128  m_prev_bb = m_bb;
129  m_bb = bb;
130  m_ii = m_bb->begin();
131  m_ie = m_bb->end();
132  }
133 
134  std::string SummarizeValue(const Value *value) {
136 
137  ss.Printf("%s", PrintValue(value).c_str());
138 
139  ValueMap::iterator i = m_values.find(value);
140 
141  if (i != m_values.end()) {
142  lldb::addr_t addr = i->second;
143 
144  ss.Printf(" 0x%llx", (unsigned long long)addr);
145  }
146 
147  return std::string(ss.GetString());
148  }
149 
150  bool AssignToMatchType(lldb_private::Scalar &scalar, llvm::APInt value,
151  Type *type) {
152  size_t type_size = m_target_data.getTypeStoreSize(type);
153 
154  if (type_size > 8)
155  return false;
156 
157  if (type_size != 1)
158  type_size = PowerOf2Ceil(type_size);
159 
160  scalar = value.zextOrTrunc(type_size * 8);
161  return true;
162  }
163 
164  bool EvaluateValue(lldb_private::Scalar &scalar, const Value *value,
165  Module &module) {
166  const Constant *constant = dyn_cast<Constant>(value);
167 
168  if (constant) {
169  APInt value_apint;
170 
171  if (!ResolveConstantValue(value_apint, constant))
172  return false;
173 
174  return AssignToMatchType(scalar, value_apint, value->getType());
175  }
176 
177  lldb::addr_t process_address = ResolveValue(value, module);
178  size_t value_size = m_target_data.getTypeStoreSize(value->getType());
179 
180  lldb_private::DataExtractor value_extractor;
181  lldb_private::Status extract_error;
182 
183  m_execution_unit.GetMemoryData(value_extractor, process_address,
184  value_size, extract_error);
185 
186  if (!extract_error.Success())
187  return false;
188 
189  lldb::offset_t offset = 0;
190  if (value_size <= 8) {
191  uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size);
192  return AssignToMatchType(scalar, llvm::APInt(64, u64value),
193  value->getType());
194  }
195 
196  return false;
197  }
198 
199  bool AssignValue(const Value *value, lldb_private::Scalar scalar,
200  Module &module) {
201  lldb::addr_t process_address = ResolveValue(value, module);
202 
203  if (process_address == LLDB_INVALID_ADDRESS)
204  return false;
205 
206  lldb_private::Scalar cast_scalar;
207 
208  scalar.MakeUnsigned();
209  if (!AssignToMatchType(cast_scalar, scalar.UInt128(llvm::APInt()),
210  value->getType()))
211  return false;
212 
213  size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
214 
215  lldb_private::DataBufferHeap buf(value_byte_size, 0);
216 
217  lldb_private::Status get_data_error;
218 
219  if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(),
220  m_byte_order, get_data_error))
221  return false;
222 
223  lldb_private::Status write_error;
224 
225  m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
226  buf.GetByteSize(), write_error);
227 
228  return write_error.Success();
229  }
230 
231  bool ResolveConstantValue(APInt &value, const Constant *constant) {
232  switch (constant->getValueID()) {
233  default:
234  break;
235  case Value::FunctionVal:
236  if (const Function *constant_func = dyn_cast<Function>(constant)) {
237  lldb_private::ConstString name(constant_func->getName());
238  bool missing_weak = false;
239  lldb::addr_t addr = m_execution_unit.FindSymbol(name, missing_weak);
240  if (addr == LLDB_INVALID_ADDRESS || missing_weak)
241  return false;
242  value = APInt(m_target_data.getPointerSizeInBits(), addr);
243  return true;
244  }
245  break;
246  case Value::ConstantIntVal:
247  if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) {
248  value = constant_int->getValue();
249  return true;
250  }
251  break;
252  case Value::ConstantFPVal:
253  if (const ConstantFP *constant_fp = dyn_cast<ConstantFP>(constant)) {
254  value = constant_fp->getValueAPF().bitcastToAPInt();
255  return true;
256  }
257  break;
258  case Value::ConstantExprVal:
259  if (const ConstantExpr *constant_expr =
260  dyn_cast<ConstantExpr>(constant)) {
261  switch (constant_expr->getOpcode()) {
262  default:
263  return false;
264  case Instruction::IntToPtr:
265  case Instruction::PtrToInt:
266  case Instruction::BitCast:
267  return ResolveConstantValue(value, constant_expr->getOperand(0));
268  case Instruction::GetElementPtr: {
269  ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin();
270  ConstantExpr::const_op_iterator op_end = constant_expr->op_end();
271 
272  Constant *base = dyn_cast<Constant>(*op_cursor);
273 
274  if (!base)
275  return false;
276 
277  if (!ResolveConstantValue(value, base))
278  return false;
279 
280  op_cursor++;
281 
282  if (op_cursor == op_end)
283  return true; // no offset to apply!
284 
285  SmallVector<Value *, 8> indices(op_cursor, op_end);
286 
287  Type *src_elem_ty =
288  cast<GEPOperator>(constant_expr)->getSourceElementType();
289  uint64_t offset =
290  m_target_data.getIndexedOffsetInType(src_elem_ty, indices);
291 
292  const bool is_signed = true;
293  value += APInt(value.getBitWidth(), offset, is_signed);
294 
295  return true;
296  }
297  }
298  }
299  break;
300  case Value::ConstantPointerNullVal:
301  if (isa<ConstantPointerNull>(constant)) {
302  value = APInt(m_target_data.getPointerSizeInBits(), 0);
303  return true;
304  }
305  break;
306  }
307  return false;
308  }
309 
310  bool MakeArgument(const Argument *value, uint64_t address) {
311  lldb::addr_t data_address = Malloc(value->getType());
312 
313  if (data_address == LLDB_INVALID_ADDRESS)
314  return false;
315 
316  lldb_private::Status write_error;
317 
318  m_execution_unit.WritePointerToMemory(data_address, address, write_error);
319 
320  if (!write_error.Success()) {
321  lldb_private::Status free_error;
322  m_execution_unit.Free(data_address, free_error);
323  return false;
324  }
325 
326  m_values[value] = data_address;
327 
328  lldb_private::Log *log(
330 
331  if (log) {
332  LLDB_LOGF(log, "Made an allocation for argument %s",
333  PrintValue(value).c_str());
334  LLDB_LOGF(log, " Data region : %llx", (unsigned long long)address);
335  LLDB_LOGF(log, " Ref region : %llx",
336  (unsigned long long)data_address);
337  }
338 
339  return true;
340  }
341 
342  bool ResolveConstant(lldb::addr_t process_address, const Constant *constant) {
343  APInt resolved_value;
344 
345  if (!ResolveConstantValue(resolved_value, constant))
346  return false;
347 
348  size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
349  lldb_private::DataBufferHeap buf(constant_size, 0);
350 
351  lldb_private::Status get_data_error;
352 
353  lldb_private::Scalar resolved_scalar(
354  resolved_value.zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8));
355  if (!resolved_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(),
356  m_byte_order, get_data_error))
357  return false;
358 
359  lldb_private::Status write_error;
360 
361  m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
362  buf.GetByteSize(), write_error);
363 
364  return write_error.Success();
365  }
366 
367  lldb::addr_t Malloc(size_t size, uint8_t byte_alignment) {
368  lldb::addr_t ret = m_stack_pointer;
369 
370  ret -= size;
371  ret -= (ret % byte_alignment);
372 
373  if (ret < m_frame_process_address)
374  return LLDB_INVALID_ADDRESS;
375 
376  m_stack_pointer = ret;
377  return ret;
378  }
379 
380  lldb::addr_t Malloc(llvm::Type *type) {
381  lldb_private::Status alloc_error;
382 
383  return Malloc(m_target_data.getTypeAllocSize(type),
384  m_target_data.getPrefTypeAlignment(type));
385  }
386 
387  std::string PrintData(lldb::addr_t addr, llvm::Type *type) {
388  size_t length = m_target_data.getTypeStoreSize(type);
389 
390  lldb_private::DataBufferHeap buf(length, 0);
391 
392  lldb_private::Status read_error;
393 
394  m_execution_unit.ReadMemory(buf.GetBytes(), addr, length, read_error);
395 
396  if (!read_error.Success())
397  return std::string("<couldn't read data>");
398 
400 
401  for (size_t i = 0; i < length; i++) {
402  if ((!(i & 0xf)) && i)
403  ss.Printf("%02hhx - ", buf.GetBytes()[i]);
404  else
405  ss.Printf("%02hhx ", buf.GetBytes()[i]);
406  }
407 
408  return std::string(ss.GetString());
409  }
410 
411  lldb::addr_t ResolveValue(const Value *value, Module &module) {
412  ValueMap::iterator i = m_values.find(value);
413 
414  if (i != m_values.end())
415  return i->second;
416 
417  // Fall back and allocate space [allocation type Alloca]
418 
419  lldb::addr_t data_address = Malloc(value->getType());
420 
421  if (const Constant *constant = dyn_cast<Constant>(value)) {
422  if (!ResolveConstant(data_address, constant)) {
423  lldb_private::Status free_error;
424  m_execution_unit.Free(data_address, free_error);
425  return LLDB_INVALID_ADDRESS;
426  }
427  }
428 
429  m_values[value] = data_address;
430  return data_address;
431  }
432 };
433 
434 static const char *unsupported_opcode_error =
435  "Interpreter doesn't handle one of the expression's opcodes";
436 static const char *unsupported_operand_error =
437  "Interpreter doesn't handle one of the expression's operands";
438 static const char *interpreter_internal_error =
439  "Interpreter encountered an internal error";
440 static const char *bad_value_error =
441  "Interpreter couldn't resolve a value during execution";
442 static const char *memory_allocation_error =
443  "Interpreter couldn't allocate memory";
444 static const char *memory_write_error = "Interpreter couldn't write to memory";
445 static const char *memory_read_error = "Interpreter couldn't read from memory";
446 static const char *infinite_loop_error = "Interpreter ran for too many cycles";
447 static const char *too_many_functions_error =
448  "Interpreter doesn't handle modules with multiple function bodies.";
449 
450 static bool CanResolveConstant(llvm::Constant *constant) {
451  switch (constant->getValueID()) {
452  default:
453  return false;
454  case Value::ConstantIntVal:
455  case Value::ConstantFPVal:
456  case Value::FunctionVal:
457  return true;
458  case Value::ConstantExprVal:
459  if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) {
460  switch (constant_expr->getOpcode()) {
461  default:
462  return false;
463  case Instruction::IntToPtr:
464  case Instruction::PtrToInt:
465  case Instruction::BitCast:
466  return CanResolveConstant(constant_expr->getOperand(0));
467  case Instruction::GetElementPtr: {
468  ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin();
469  Constant *base = dyn_cast<Constant>(*op_cursor);
470  if (!base)
471  return false;
472 
473  return CanResolveConstant(base);
474  }
475  }
476  } else {
477  return false;
478  }
479  case Value::ConstantPointerNullVal:
480  return true;
481  }
482 }
483 
484 bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
486  const bool support_function_calls) {
487  lldb_private::Log *log(
489 
490  bool saw_function_with_body = false;
491  for (Function &f : module) {
492  if (f.begin() != f.end()) {
493  if (saw_function_with_body) {
494  LLDB_LOGF(log, "More than one function in the module has a body");
495  error.SetErrorToGenericError();
496  error.SetErrorString(too_many_functions_error);
497  return false;
498  }
499  saw_function_with_body = true;
500  }
501  }
502 
503  for (BasicBlock &bb : function) {
504  for (Instruction &ii : bb) {
505  switch (ii.getOpcode()) {
506  default: {
507  LLDB_LOGF(log, "Unsupported instruction: %s", PrintValue(&ii).c_str());
508  error.SetErrorToGenericError();
509  error.SetErrorString(unsupported_opcode_error);
510  return false;
511  }
512  case Instruction::Add:
513  case Instruction::Alloca:
514  case Instruction::BitCast:
515  case Instruction::Br:
516  case Instruction::PHI:
517  break;
518  case Instruction::Call: {
519  CallInst *call_inst = dyn_cast<CallInst>(&ii);
520 
521  if (!call_inst) {
522  error.SetErrorToGenericError();
523  error.SetErrorString(interpreter_internal_error);
524  return false;
525  }
526 
527  if (!CanIgnoreCall(call_inst) && !support_function_calls) {
528  LLDB_LOGF(log, "Unsupported instruction: %s",
529  PrintValue(&ii).c_str());
530  error.SetErrorToGenericError();
531  error.SetErrorString(unsupported_opcode_error);
532  return false;
533  }
534  } break;
535  case Instruction::GetElementPtr:
536  break;
537  case Instruction::ICmp: {
538  ICmpInst *icmp_inst = dyn_cast<ICmpInst>(&ii);
539 
540  if (!icmp_inst) {
541  error.SetErrorToGenericError();
542  error.SetErrorString(interpreter_internal_error);
543  return false;
544  }
545 
546  switch (icmp_inst->getPredicate()) {
547  default: {
548  LLDB_LOGF(log, "Unsupported ICmp predicate: %s",
549  PrintValue(&ii).c_str());
550 
551  error.SetErrorToGenericError();
552  error.SetErrorString(unsupported_opcode_error);
553  return false;
554  }
555  case CmpInst::ICMP_EQ:
556  case CmpInst::ICMP_NE:
557  case CmpInst::ICMP_UGT:
558  case CmpInst::ICMP_UGE:
559  case CmpInst::ICMP_ULT:
560  case CmpInst::ICMP_ULE:
561  case CmpInst::ICMP_SGT:
562  case CmpInst::ICMP_SGE:
563  case CmpInst::ICMP_SLT:
564  case CmpInst::ICMP_SLE:
565  break;
566  }
567  } break;
568  case Instruction::And:
569  case Instruction::AShr:
570  case Instruction::IntToPtr:
571  case Instruction::PtrToInt:
572  case Instruction::Load:
573  case Instruction::LShr:
574  case Instruction::Mul:
575  case Instruction::Or:
576  case Instruction::Ret:
577  case Instruction::SDiv:
578  case Instruction::SExt:
579  case Instruction::Shl:
580  case Instruction::SRem:
581  case Instruction::Store:
582  case Instruction::Sub:
583  case Instruction::Trunc:
584  case Instruction::UDiv:
585  case Instruction::URem:
586  case Instruction::Xor:
587  case Instruction::ZExt:
588  break;
589  }
590 
591  for (unsigned oi = 0, oe = ii.getNumOperands(); oi != oe; ++oi) {
592  Value *operand = ii.getOperand(oi);
593  Type *operand_type = operand->getType();
594 
595  switch (operand_type->getTypeID()) {
596  default:
597  break;
598  case Type::FixedVectorTyID:
599  case Type::ScalableVectorTyID: {
600  LLDB_LOGF(log, "Unsupported operand type: %s",
601  PrintType(operand_type).c_str());
602  error.SetErrorString(unsupported_operand_error);
603  return false;
604  }
605  }
606 
607  // The IR interpreter currently doesn't know about
608  // 128-bit integers. As they're not that frequent,
609  // we can just fall back to the JIT rather than
610  // choking.
611  if (operand_type->getPrimitiveSizeInBits() > 64) {
612  LLDB_LOGF(log, "Unsupported operand type: %s",
613  PrintType(operand_type).c_str());
614  error.SetErrorString(unsupported_operand_error);
615  return false;
616  }
617 
618  if (Constant *constant = llvm::dyn_cast<Constant>(operand)) {
619  if (!CanResolveConstant(constant)) {
620  LLDB_LOGF(log, "Unsupported constant: %s",
621  PrintValue(constant).c_str());
622  error.SetErrorString(unsupported_operand_error);
623  return false;
624  }
625  }
626  }
627  }
628  }
629 
630  return true;
631 }
632 
633 bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
634  llvm::ArrayRef<lldb::addr_t> args,
635  lldb_private::IRExecutionUnit &execution_unit,
637  lldb::addr_t stack_frame_bottom,
638  lldb::addr_t stack_frame_top,
640  lldb_private::Log *log(
642 
643  if (log) {
644  std::string s;
645  raw_string_ostream oss(s);
646 
647  module.print(oss, nullptr);
648 
649  oss.flush();
650 
651  LLDB_LOGF(log, "Module as passed in to IRInterpreter::Interpret: \n\"%s\"",
652  s.c_str());
653  }
654 
655  DataLayout data_layout(&module);
656 
657  InterpreterStackFrame frame(data_layout, execution_unit, stack_frame_bottom,
658  stack_frame_top);
659 
661  error.SetErrorString("Couldn't allocate stack frame");
662  }
663 
664  int arg_index = 0;
665 
666  for (llvm::Function::arg_iterator ai = function.arg_begin(),
667  ae = function.arg_end();
668  ai != ae; ++ai, ++arg_index) {
669  if (args.size() <= static_cast<size_t>(arg_index)) {
670  error.SetErrorString("Not enough arguments passed in to function");
671  return false;
672  }
673 
674  lldb::addr_t ptr = args[arg_index];
675 
676  frame.MakeArgument(&*ai, ptr);
677  }
678 
679  uint32_t num_insts = 0;
680 
681  frame.Jump(&function.front());
682 
683  while (frame.m_ii != frame.m_ie && (++num_insts < 4096)) {
684  const Instruction *inst = &*frame.m_ii;
685 
686  LLDB_LOGF(log, "Interpreting %s", PrintValue(inst).c_str());
687 
688  switch (inst->getOpcode()) {
689  default:
690  break;
691 
692  case Instruction::Add:
693  case Instruction::Sub:
694  case Instruction::Mul:
695  case Instruction::SDiv:
696  case Instruction::UDiv:
697  case Instruction::SRem:
698  case Instruction::URem:
699  case Instruction::Shl:
700  case Instruction::LShr:
701  case Instruction::AShr:
702  case Instruction::And:
703  case Instruction::Or:
704  case Instruction::Xor: {
705  const BinaryOperator *bin_op = dyn_cast<BinaryOperator>(inst);
706 
707  if (!bin_op) {
708  LLDB_LOGF(
709  log,
710  "getOpcode() returns %s, but instruction is not a BinaryOperator",
711  inst->getOpcodeName());
712  error.SetErrorToGenericError();
713  error.SetErrorString(interpreter_internal_error);
714  return false;
715  }
716 
717  Value *lhs = inst->getOperand(0);
718  Value *rhs = inst->getOperand(1);
719 
722 
723  if (!frame.EvaluateValue(L, lhs, module)) {
724  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(lhs).c_str());
725  error.SetErrorToGenericError();
726  error.SetErrorString(bad_value_error);
727  return false;
728  }
729 
730  if (!frame.EvaluateValue(R, rhs, module)) {
731  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(rhs).c_str());
732  error.SetErrorToGenericError();
733  error.SetErrorString(bad_value_error);
734  return false;
735  }
736 
737  lldb_private::Scalar result;
738 
739  switch (inst->getOpcode()) {
740  default:
741  break;
742  case Instruction::Add:
743  result = L + R;
744  break;
745  case Instruction::Mul:
746  result = L * R;
747  break;
748  case Instruction::Sub:
749  result = L - R;
750  break;
751  case Instruction::SDiv:
752  L.MakeSigned();
753  R.MakeSigned();
754  result = L / R;
755  break;
756  case Instruction::UDiv:
757  L.MakeUnsigned();
758  R.MakeUnsigned();
759  result = L / R;
760  break;
761  case Instruction::SRem:
762  L.MakeSigned();
763  R.MakeSigned();
764  result = L % R;
765  break;
766  case Instruction::URem:
767  L.MakeUnsigned();
768  R.MakeUnsigned();
769  result = L % R;
770  break;
771  case Instruction::Shl:
772  result = L << R;
773  break;
774  case Instruction::AShr:
775  result = L >> R;
776  break;
777  case Instruction::LShr:
778  result = L;
779  result.ShiftRightLogical(R);
780  break;
781  case Instruction::And:
782  result = L & R;
783  break;
784  case Instruction::Or:
785  result = L | R;
786  break;
787  case Instruction::Xor:
788  result = L ^ R;
789  break;
790  }
791 
792  frame.AssignValue(inst, result, module);
793 
794  if (log) {
795  LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
796  LLDB_LOGF(log, " L : %s", frame.SummarizeValue(lhs).c_str());
797  LLDB_LOGF(log, " R : %s", frame.SummarizeValue(rhs).c_str());
798  LLDB_LOGF(log, " = : %s", frame.SummarizeValue(inst).c_str());
799  }
800  } break;
801  case Instruction::Alloca: {
802  const AllocaInst *alloca_inst = cast<AllocaInst>(inst);
803 
804  if (alloca_inst->isArrayAllocation()) {
805  LLDB_LOGF(log,
806  "AllocaInsts are not handled if isArrayAllocation() is true");
807  error.SetErrorToGenericError();
808  error.SetErrorString(unsupported_opcode_error);
809  return false;
810  }
811 
812  // The semantics of Alloca are:
813  // Create a region R of virtual memory of type T, backed by a data
814  // buffer
815  // Create a region P of virtual memory of type T*, backed by a data
816  // buffer
817  // Write the virtual address of R into P
818 
819  Type *T = alloca_inst->getAllocatedType();
820  Type *Tptr = alloca_inst->getType();
821 
822  lldb::addr_t R = frame.Malloc(T);
823 
824  if (R == LLDB_INVALID_ADDRESS) {
825  LLDB_LOGF(log, "Couldn't allocate memory for an AllocaInst");
826  error.SetErrorToGenericError();
827  error.SetErrorString(memory_allocation_error);
828  return false;
829  }
830 
831  lldb::addr_t P = frame.Malloc(Tptr);
832 
833  if (P == LLDB_INVALID_ADDRESS) {
834  LLDB_LOGF(log,
835  "Couldn't allocate the result pointer for an AllocaInst");
836  error.SetErrorToGenericError();
837  error.SetErrorString(memory_allocation_error);
838  return false;
839  }
840 
841  lldb_private::Status write_error;
842 
843  execution_unit.WritePointerToMemory(P, R, write_error);
844 
845  if (!write_error.Success()) {
846  LLDB_LOGF(log, "Couldn't write the result pointer for an AllocaInst");
847  error.SetErrorToGenericError();
848  error.SetErrorString(memory_write_error);
849  lldb_private::Status free_error;
850  execution_unit.Free(P, free_error);
851  execution_unit.Free(R, free_error);
852  return false;
853  }
854 
855  frame.m_values[alloca_inst] = P;
856 
857  if (log) {
858  LLDB_LOGF(log, "Interpreted an AllocaInst");
859  LLDB_LOGF(log, " R : 0x%" PRIx64, R);
860  LLDB_LOGF(log, " P : 0x%" PRIx64, P);
861  }
862  } break;
863  case Instruction::BitCast:
864  case Instruction::ZExt: {
865  const CastInst *cast_inst = cast<CastInst>(inst);
866 
867  Value *source = cast_inst->getOperand(0);
868 
870 
871  if (!frame.EvaluateValue(S, source, module)) {
872  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
873  error.SetErrorToGenericError();
874  error.SetErrorString(bad_value_error);
875  return false;
876  }
877 
878  frame.AssignValue(inst, S, module);
879  } break;
880  case Instruction::SExt: {
881  const CastInst *cast_inst = cast<CastInst>(inst);
882 
883  Value *source = cast_inst->getOperand(0);
884 
886 
887  if (!frame.EvaluateValue(S, source, module)) {
888  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
889  error.SetErrorToGenericError();
890  error.SetErrorString(bad_value_error);
891  return false;
892  }
893 
894  S.MakeSigned();
895 
896  lldb_private::Scalar S_signextend(S.SLongLong());
897 
898  frame.AssignValue(inst, S_signextend, module);
899  } break;
900  case Instruction::Br: {
901  const BranchInst *br_inst = cast<BranchInst>(inst);
902 
903  if (br_inst->isConditional()) {
904  Value *condition = br_inst->getCondition();
905 
907 
908  if (!frame.EvaluateValue(C, condition, module)) {
909  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(condition).c_str());
910  error.SetErrorToGenericError();
911  error.SetErrorString(bad_value_error);
912  return false;
913  }
914 
915  if (!C.IsZero())
916  frame.Jump(br_inst->getSuccessor(0));
917  else
918  frame.Jump(br_inst->getSuccessor(1));
919 
920  if (log) {
921  LLDB_LOGF(log, "Interpreted a BrInst with a condition");
922  LLDB_LOGF(log, " cond : %s",
923  frame.SummarizeValue(condition).c_str());
924  }
925  } else {
926  frame.Jump(br_inst->getSuccessor(0));
927 
928  if (log) {
929  LLDB_LOGF(log, "Interpreted a BrInst with no condition");
930  }
931  }
932  }
933  continue;
934  case Instruction::PHI: {
935  const PHINode *phi_inst = cast<PHINode>(inst);
936  if (!frame.m_prev_bb) {
937  LLDB_LOGF(log,
938  "Encountered PHI node without having jumped from another "
939  "basic block");
940  error.SetErrorToGenericError();
941  error.SetErrorString(interpreter_internal_error);
942  return false;
943  }
944 
945  Value *value = phi_inst->getIncomingValueForBlock(frame.m_prev_bb);
946  lldb_private::Scalar result;
947  if (!frame.EvaluateValue(result, value, module)) {
948  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(value).c_str());
949  error.SetErrorToGenericError();
950  error.SetErrorString(bad_value_error);
951  return false;
952  }
953  frame.AssignValue(inst, result, module);
954 
955  if (log) {
956  LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
957  LLDB_LOGF(log, " Incoming value : %s",
958  frame.SummarizeValue(value).c_str());
959  }
960  } break;
961  case Instruction::GetElementPtr: {
962  const GetElementPtrInst *gep_inst = cast<GetElementPtrInst>(inst);
963 
964  const Value *pointer_operand = gep_inst->getPointerOperand();
965  Type *src_elem_ty = gep_inst->getSourceElementType();
966 
968 
969  if (!frame.EvaluateValue(P, pointer_operand, module)) {
970  LLDB_LOGF(log, "Couldn't evaluate %s",
971  PrintValue(pointer_operand).c_str());
972  error.SetErrorToGenericError();
973  error.SetErrorString(bad_value_error);
974  return false;
975  }
976 
977  typedef SmallVector<Value *, 8> IndexVector;
978  typedef IndexVector::iterator IndexIterator;
979 
980  SmallVector<Value *, 8> indices(gep_inst->idx_begin(),
981  gep_inst->idx_end());
982 
983  SmallVector<Value *, 8> const_indices;
984 
985  for (IndexIterator ii = indices.begin(), ie = indices.end(); ii != ie;
986  ++ii) {
987  ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii);
988 
989  if (!constant_index) {
991 
992  if (!frame.EvaluateValue(I, *ii, module)) {
993  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(*ii).c_str());
994  error.SetErrorToGenericError();
995  error.SetErrorString(bad_value_error);
996  return false;
997  }
998 
999  LLDB_LOGF(log, "Evaluated constant index %s as %llu",
1000  PrintValue(*ii).c_str(), I.ULongLong(LLDB_INVALID_ADDRESS));
1001 
1002  constant_index = cast<ConstantInt>(ConstantInt::get(
1003  (*ii)->getType(), I.ULongLong(LLDB_INVALID_ADDRESS)));
1004  }
1005 
1006  const_indices.push_back(constant_index);
1007  }
1008 
1009  uint64_t offset =
1010  data_layout.getIndexedOffsetInType(src_elem_ty, const_indices);
1011 
1012  lldb_private::Scalar Poffset = P + offset;
1013 
1014  frame.AssignValue(inst, Poffset, module);
1015 
1016  if (log) {
1017  LLDB_LOGF(log, "Interpreted a GetElementPtrInst");
1018  LLDB_LOGF(log, " P : %s",
1019  frame.SummarizeValue(pointer_operand).c_str());
1020  LLDB_LOGF(log, " Poffset : %s", frame.SummarizeValue(inst).c_str());
1021  }
1022  } break;
1023  case Instruction::ICmp: {
1024  const ICmpInst *icmp_inst = cast<ICmpInst>(inst);
1025 
1026  CmpInst::Predicate predicate = icmp_inst->getPredicate();
1027 
1028  Value *lhs = inst->getOperand(0);
1029  Value *rhs = inst->getOperand(1);
1030 
1033 
1034  if (!frame.EvaluateValue(L, lhs, module)) {
1035  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(lhs).c_str());
1036  error.SetErrorToGenericError();
1037  error.SetErrorString(bad_value_error);
1038  return false;
1039  }
1040 
1041  if (!frame.EvaluateValue(R, rhs, module)) {
1042  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(rhs).c_str());
1043  error.SetErrorToGenericError();
1044  error.SetErrorString(bad_value_error);
1045  return false;
1046  }
1047 
1048  lldb_private::Scalar result;
1049 
1050  switch (predicate) {
1051  default:
1052  return false;
1053  case CmpInst::ICMP_EQ:
1054  result = (L == R);
1055  break;
1056  case CmpInst::ICMP_NE:
1057  result = (L != R);
1058  break;
1059  case CmpInst::ICMP_UGT:
1060  L.MakeUnsigned();
1061  R.MakeUnsigned();
1062  result = (L > R);
1063  break;
1064  case CmpInst::ICMP_UGE:
1065  L.MakeUnsigned();
1066  R.MakeUnsigned();
1067  result = (L >= R);
1068  break;
1069  case CmpInst::ICMP_ULT:
1070  L.MakeUnsigned();
1071  R.MakeUnsigned();
1072  result = (L < R);
1073  break;
1074  case CmpInst::ICMP_ULE:
1075  L.MakeUnsigned();
1076  R.MakeUnsigned();
1077  result = (L <= R);
1078  break;
1079  case CmpInst::ICMP_SGT:
1080  L.MakeSigned();
1081  R.MakeSigned();
1082  result = (L > R);
1083  break;
1084  case CmpInst::ICMP_SGE:
1085  L.MakeSigned();
1086  R.MakeSigned();
1087  result = (L >= R);
1088  break;
1089  case CmpInst::ICMP_SLT:
1090  L.MakeSigned();
1091  R.MakeSigned();
1092  result = (L < R);
1093  break;
1094  case CmpInst::ICMP_SLE:
1095  L.MakeSigned();
1096  R.MakeSigned();
1097  result = (L <= R);
1098  break;
1099  }
1100 
1101  frame.AssignValue(inst, result, module);
1102 
1103  if (log) {
1104  LLDB_LOGF(log, "Interpreted an ICmpInst");
1105  LLDB_LOGF(log, " L : %s", frame.SummarizeValue(lhs).c_str());
1106  LLDB_LOGF(log, " R : %s", frame.SummarizeValue(rhs).c_str());
1107  LLDB_LOGF(log, " = : %s", frame.SummarizeValue(inst).c_str());
1108  }
1109  } break;
1110  case Instruction::IntToPtr: {
1111  const IntToPtrInst *int_to_ptr_inst = cast<IntToPtrInst>(inst);
1112 
1113  Value *src_operand = int_to_ptr_inst->getOperand(0);
1114 
1116 
1117  if (!frame.EvaluateValue(I, src_operand, module)) {
1118  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1119  error.SetErrorToGenericError();
1120  error.SetErrorString(bad_value_error);
1121  return false;
1122  }
1123 
1124  frame.AssignValue(inst, I, module);
1125 
1126  if (log) {
1127  LLDB_LOGF(log, "Interpreted an IntToPtr");
1128  LLDB_LOGF(log, " Src : %s", frame.SummarizeValue(src_operand).c_str());
1129  LLDB_LOGF(log, " = : %s", frame.SummarizeValue(inst).c_str());
1130  }
1131  } break;
1132  case Instruction::PtrToInt: {
1133  const PtrToIntInst *ptr_to_int_inst = cast<PtrToIntInst>(inst);
1134 
1135  Value *src_operand = ptr_to_int_inst->getOperand(0);
1136 
1138 
1139  if (!frame.EvaluateValue(I, src_operand, module)) {
1140  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1141  error.SetErrorToGenericError();
1142  error.SetErrorString(bad_value_error);
1143  return false;
1144  }
1145 
1146  frame.AssignValue(inst, I, module);
1147 
1148  if (log) {
1149  LLDB_LOGF(log, "Interpreted a PtrToInt");
1150  LLDB_LOGF(log, " Src : %s", frame.SummarizeValue(src_operand).c_str());
1151  LLDB_LOGF(log, " = : %s", frame.SummarizeValue(inst).c_str());
1152  }
1153  } break;
1154  case Instruction::Trunc: {
1155  const TruncInst *trunc_inst = cast<TruncInst>(inst);
1156 
1157  Value *src_operand = trunc_inst->getOperand(0);
1158 
1160 
1161  if (!frame.EvaluateValue(I, src_operand, module)) {
1162  LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1163  error.SetErrorToGenericError();
1164  error.SetErrorString(bad_value_error);
1165  return false;
1166  }
1167 
1168  frame.AssignValue(inst, I, module);
1169 
1170  if (log) {
1171  LLDB_LOGF(log, "Interpreted a Trunc");
1172  LLDB_LOGF(log, " Src : %s", frame.SummarizeValue(src_operand).c_str());
1173  LLDB_LOGF(log, " = : %s", frame.SummarizeValue(inst).c_str());
1174  }
1175  } break;
1176  case Instruction::Load: {
1177  const LoadInst *load_inst = cast<LoadInst>(inst);
1178 
1179  // The semantics of Load are:
1180  // Create a region D that will contain the loaded data
1181  // Resolve the region P containing a pointer
1182  // Dereference P to get the region R that the data should be loaded from
1183  // Transfer a unit of type type(D) from R to D
1184 
1185  const Value *pointer_operand = load_inst->getPointerOperand();
1186 
1187  Type *pointer_ty = pointer_operand->getType();
1188  PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);
1189  if (!pointer_ptr_ty) {
1190  LLDB_LOGF(log, "getPointerOperand()->getType() is not a PointerType");
1191  error.SetErrorToGenericError();
1192  error.SetErrorString(interpreter_internal_error);
1193  return false;
1194  }
1195  Type *target_ty = pointer_ptr_ty->getElementType();
1196 
1197  lldb::addr_t D = frame.ResolveValue(load_inst, module);
1198  lldb::addr_t P = frame.ResolveValue(pointer_operand, module);
1199 
1200  if (D == LLDB_INVALID_ADDRESS) {
1201  LLDB_LOGF(log, "LoadInst's value doesn't resolve to anything");
1202  error.SetErrorToGenericError();
1203  error.SetErrorString(bad_value_error);
1204  return false;
1205  }
1206 
1207  if (P == LLDB_INVALID_ADDRESS) {
1208  LLDB_LOGF(log, "LoadInst's pointer doesn't resolve to anything");
1209  error.SetErrorToGenericError();
1210  error.SetErrorString(bad_value_error);
1211  return false;
1212  }
1213 
1214  lldb::addr_t R;
1215  lldb_private::Status read_error;
1216  execution_unit.ReadPointerFromMemory(&R, P, read_error);
1217 
1218  if (!read_error.Success()) {
1219  LLDB_LOGF(log, "Couldn't read the address to be loaded for a LoadInst");
1220  error.SetErrorToGenericError();
1221  error.SetErrorString(memory_read_error);
1222  return false;
1223  }
1224 
1225  size_t target_size = data_layout.getTypeStoreSize(target_ty);
1226  lldb_private::DataBufferHeap buffer(target_size, 0);
1227 
1228  read_error.Clear();
1229  execution_unit.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(),
1230  read_error);
1231  if (!read_error.Success()) {
1232  LLDB_LOGF(log, "Couldn't read from a region on behalf of a LoadInst");
1233  error.SetErrorToGenericError();
1234  error.SetErrorString(memory_read_error);
1235  return false;
1236  }
1237 
1238  lldb_private::Status write_error;
1239  execution_unit.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(),
1240  write_error);
1241  if (!write_error.Success()) {
1242  LLDB_LOGF(log, "Couldn't write to a region on behalf of a LoadInst");
1243  error.SetErrorToGenericError();
1244  error.SetErrorString(memory_write_error);
1245  return false;
1246  }
1247 
1248  if (log) {
1249  LLDB_LOGF(log, "Interpreted a LoadInst");
1250  LLDB_LOGF(log, " P : 0x%" PRIx64, P);
1251  LLDB_LOGF(log, " R : 0x%" PRIx64, R);
1252  LLDB_LOGF(log, " D : 0x%" PRIx64, D);
1253  }
1254  } break;
1255  case Instruction::Ret: {
1256  return true;
1257  }
1258  case Instruction::Store: {
1259  const StoreInst *store_inst = cast<StoreInst>(inst);
1260 
1261  // The semantics of Store are:
1262  // Resolve the region D containing the data to be stored
1263  // Resolve the region P containing a pointer
1264  // Dereference P to get the region R that the data should be stored in
1265  // Transfer a unit of type type(D) from D to R
1266 
1267  const Value *value_operand = store_inst->getValueOperand();
1268  const Value *pointer_operand = store_inst->getPointerOperand();
1269 
1270  Type *pointer_ty = pointer_operand->getType();
1271  PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);
1272  if (!pointer_ptr_ty)
1273  return false;
1274  Type *target_ty = pointer_ptr_ty->getElementType();
1275 
1276  lldb::addr_t D = frame.ResolveValue(value_operand, module);
1277  lldb::addr_t P = frame.ResolveValue(pointer_operand, module);
1278 
1279  if (D == LLDB_INVALID_ADDRESS) {
1280  LLDB_LOGF(log, "StoreInst's value doesn't resolve to anything");
1281  error.SetErrorToGenericError();
1282  error.SetErrorString(bad_value_error);
1283  return false;
1284  }
1285 
1286  if (P == LLDB_INVALID_ADDRESS) {
1287  LLDB_LOGF(log, "StoreInst's pointer doesn't resolve to anything");
1288  error.SetErrorToGenericError();
1289  error.SetErrorString(bad_value_error);
1290  return false;
1291  }
1292 
1293  lldb::addr_t R;
1294  lldb_private::Status read_error;
1295  execution_unit.ReadPointerFromMemory(&R, P, read_error);
1296 
1297  if (!read_error.Success()) {
1298  LLDB_LOGF(log, "Couldn't read the address to be loaded for a LoadInst");
1299  error.SetErrorToGenericError();
1300  error.SetErrorString(memory_read_error);
1301  return false;
1302  }
1303 
1304  size_t target_size = data_layout.getTypeStoreSize(target_ty);
1305  lldb_private::DataBufferHeap buffer(target_size, 0);
1306 
1307  read_error.Clear();
1308  execution_unit.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(),
1309  read_error);
1310  if (!read_error.Success()) {
1311  LLDB_LOGF(log, "Couldn't read from a region on behalf of a StoreInst");
1312  error.SetErrorToGenericError();
1313  error.SetErrorString(memory_read_error);
1314  return false;
1315  }
1316 
1317  lldb_private::Status write_error;
1318  execution_unit.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(),
1319  write_error);
1320  if (!write_error.Success()) {
1321  LLDB_LOGF(log, "Couldn't write to a region on behalf of a StoreInst");
1322  error.SetErrorToGenericError();
1323  error.SetErrorString(memory_write_error);
1324  return false;
1325  }
1326 
1327  if (log) {
1328  LLDB_LOGF(log, "Interpreted a StoreInst");
1329  LLDB_LOGF(log, " D : 0x%" PRIx64, D);
1330  LLDB_LOGF(log, " P : 0x%" PRIx64, P);
1331  LLDB_LOGF(log, " R : 0x%" PRIx64, R);
1332  }
1333  } break;
1334  case Instruction::Call: {
1335  const CallInst *call_inst = cast<CallInst>(inst);
1336 
1337  if (CanIgnoreCall(call_inst))
1338  break;
1339 
1340  // Get the return type
1341  llvm::Type *returnType = call_inst->getType();
1342  if (returnType == nullptr) {
1343  error.SetErrorToGenericError();
1344  error.SetErrorString("unable to access return type");
1345  return false;
1346  }
1347 
1348  // Work with void, integer and pointer return types
1349  if (!returnType->isVoidTy() && !returnType->isIntegerTy() &&
1350  !returnType->isPointerTy()) {
1351  error.SetErrorToGenericError();
1352  error.SetErrorString("return type is not supported");
1353  return false;
1354  }
1355 
1356  // Check we can actually get a thread
1357  if (exe_ctx.GetThreadPtr() == nullptr) {
1358  error.SetErrorToGenericError();
1359  error.SetErrorString("unable to acquire thread");
1360  return false;
1361  }
1362 
1363  // Make sure we have a valid process
1364  if (!exe_ctx.GetProcessPtr()) {
1365  error.SetErrorToGenericError();
1366  error.SetErrorString("unable to get the process");
1367  return false;
1368  }
1369 
1370  // Find the address of the callee function
1372  const llvm::Value *val = call_inst->getCalledOperand();
1373 
1374  if (!frame.EvaluateValue(I, val, module)) {
1375  error.SetErrorToGenericError();
1376  error.SetErrorString("unable to get address of function");
1377  return false;
1378  }
1380 
1381  lldb_private::DiagnosticManager diagnostics;
1383 
1384  // We generally receive a function pointer which we must dereference
1385  llvm::Type *prototype = val->getType();
1386  if (!prototype->isPointerTy()) {
1387  error.SetErrorToGenericError();
1388  error.SetErrorString("call need function pointer");
1389  return false;
1390  }
1391 
1392  // Dereference the function pointer
1393  prototype = prototype->getPointerElementType();
1394  if (!(prototype->isFunctionTy() || prototype->isFunctionVarArg())) {
1395  error.SetErrorToGenericError();
1396  error.SetErrorString("call need function pointer");
1397  return false;
1398  }
1399 
1400  // Find number of arguments
1401  const int numArgs = call_inst->getNumArgOperands();
1402 
1403  // We work with a fixed array of 16 arguments which is our upper limit
1404  static lldb_private::ABI::CallArgument rawArgs[16];
1405  if (numArgs >= 16) {
1406  error.SetErrorToGenericError();
1407  error.SetErrorString("function takes too many arguments");
1408  return false;
1409  }
1410 
1411  // Push all function arguments to the argument list that will be passed
1412  // to the call function thread plan
1413  for (int i = 0; i < numArgs; i++) {
1414  // Get details of this argument
1415  llvm::Value *arg_op = call_inst->getArgOperand(i);
1416  llvm::Type *arg_ty = arg_op->getType();
1417 
1418  // Ensure that this argument is an supported type
1419  if (!arg_ty->isIntegerTy() && !arg_ty->isPointerTy()) {
1420  error.SetErrorToGenericError();
1421  error.SetErrorStringWithFormat("argument %d must be integer type", i);
1422  return false;
1423  }
1424 
1425  // Extract the arguments value
1426  lldb_private::Scalar tmp_op = 0;
1427  if (!frame.EvaluateValue(tmp_op, arg_op, module)) {
1428  error.SetErrorToGenericError();
1429  error.SetErrorStringWithFormat("unable to evaluate argument %d", i);
1430  return false;
1431  }
1432 
1433  // Check if this is a string literal or constant string pointer
1434  if (arg_ty->isPointerTy()) {
1435  lldb::addr_t addr = tmp_op.ULongLong();
1436  size_t dataSize = 0;
1437 
1438  bool Success = execution_unit.GetAllocSize(addr, dataSize);
1439  (void)Success;
1440  assert(Success &&
1441  "unable to locate host data for transfer to device");
1442  // Create the required buffer
1443  rawArgs[i].size = dataSize;
1444  rawArgs[i].data_up.reset(new uint8_t[dataSize + 1]);
1445 
1446  // Read string from host memory
1447  execution_unit.ReadMemory(rawArgs[i].data_up.get(), addr, dataSize,
1448  error);
1449  assert(!error.Fail() &&
1450  "we have failed to read the string from memory");
1451 
1452  // Add null terminator
1453  rawArgs[i].data_up[dataSize] = '\0';
1455  } else /* if ( arg_ty->isPointerTy() ) */
1456  {
1458  // Get argument size in bytes
1459  rawArgs[i].size = arg_ty->getIntegerBitWidth() / 8;
1460  // Push value into argument list for thread plan
1461  rawArgs[i].value = tmp_op.ULongLong();
1462  }
1463  }
1464 
1465  // Pack the arguments into an llvm::array
1466  llvm::ArrayRef<lldb_private::ABI::CallArgument> args(rawArgs, numArgs);
1467 
1468  // Setup a thread plan to call the target function
1469  lldb::ThreadPlanSP call_plan_sp(
1471  exe_ctx.GetThreadRef(), funcAddr, *prototype, *returnType, args,
1472  options));
1473 
1474  // Check if the plan is valid
1476  if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
1477  error.SetErrorToGenericError();
1478  error.SetErrorStringWithFormat(
1479  "unable to make ThreadPlanCallFunctionUsingABI for 0x%llx",
1480  I.ULongLong());
1481  return false;
1482  }
1483 
1484  exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
1485 
1486  // Execute the actual function call thread plan
1488  exe_ctx, call_plan_sp, options, diagnostics);
1489 
1490  // Check that the thread plan completed successfully
1492  error.SetErrorToGenericError();
1493  error.SetErrorString("ThreadPlanCallFunctionUsingABI failed");
1494  return false;
1495  }
1496 
1497  exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
1498 
1499  // Void return type
1500  if (returnType->isVoidTy()) {
1501  // Cant assign to void types, so we leave the frame untouched
1502  } else
1503  // Integer or pointer return type
1504  if (returnType->isIntegerTy() || returnType->isPointerTy()) {
1505  // Get the encapsulated return value
1506  lldb::ValueObjectSP retVal = call_plan_sp.get()->GetReturnValueObject();
1507 
1508  lldb_private::Scalar returnVal = -1;
1509  lldb_private::ValueObject *vobj = retVal.get();
1510 
1511  // Check if the return value is valid
1512  if (vobj == nullptr || !retVal) {
1513  error.SetErrorToGenericError();
1514  error.SetErrorString("unable to get the return value");
1515  return false;
1516  }
1517 
1518  // Extract the return value as a integer
1519  lldb_private::Value &value = vobj->GetValue();
1520  returnVal = value.GetScalar();
1521 
1522  // Push the return value as the result
1523  frame.AssignValue(inst, returnVal, module);
1524  }
1525  } break;
1526  }
1527 
1528  ++frame.m_ii;
1529  }
1530 
1531  if (num_insts >= 4096) {
1532  error.SetErrorToGenericError();
1533  error.SetErrorString(infinite_loop_error);
1534  return false;
1535  }
1536 
1537  return false;
1538 }
lldb_private::IRExecutionUnit
Definition: IRExecutionUnit.h:56
lldb_private::ABI::CallArgument::TargetValue
@ TargetValue
Definition: ABI.h:31
lldb_private::ExecutionContext
Definition: ExecutionContext.h:291
lldb_private::DataBufferHeap::GetBytes
uint8_t * GetBytes() override
Definition: DataBufferHeap.cpp:34
lldb_private::DataBufferHeap::GetByteSize
lldb::offset_t GetByteSize() const override
Definition: DataBufferHeap.cpp:45
lldb_private::ThreadPlanCallFunctionUsingABI
Definition: ThreadPlanCallFunctionUsingABI.h:23
Scalar.h
llvm
Definition: Debugger.h:49
memory_allocation_error
static const char * memory_allocation_error
Definition: IRInterpreter.cpp:442
IRMemoryMap.h
InterpreterStackFrame::m_frame_size
size_t m_frame_size
Definition: IRInterpreter.cpp:104
ModuleSpec.h
lldb_private::ValueObject::GetValue
const Value & GetValue() const
Definition: ValueObject.h:497
InterpreterStackFrame::Malloc
lldb::addr_t Malloc(llvm::Type *type)
Definition: IRInterpreter.cpp:380
lldb_private::Process::SetRunningUserExpression
void SetRunningUserExpression(bool on)
Definition: Process.cpp:1443
lldb_private::Value
Definition: Value.h:38
lldb_private::ExecutionContext::GetProcessPtr
Process * GetProcessPtr() const
Returns a pointer to the process object.
Definition: ExecutionContext.cpp:208
InterpreterStackFrame::ValueMap
std::map< const Value *, lldb::addr_t > ValueMap
Definition: IRInterpreter.cpp:93
too_many_functions_error
static const char * too_many_functions_error
Definition: IRInterpreter.cpp:447
lldb::ExpressionResults
ExpressionResults
The results of expression evaluation.
Definition: lldb-enumerations.h:270
InterpreterStackFrame::ResolveValue
lldb::addr_t ResolveValue(const Value *value, Module &module)
Definition: IRInterpreter.cpp:411
InterpreterStackFrame::m_frame_process_address
lldb::addr_t m_frame_process_address
Definition: IRInterpreter.cpp:103
lldb_private::ABI::CallArgument::type
eType type
Definition: ABI.h:33
lldb_private::Scalar
Definition: Scalar.h:34
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb_private::Scalar::GetAsMemoryData
size_t GetAsMemoryData(void *dst, size_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
Definition: Scalar.cpp:773
InterpreterStackFrame::PrintData
std::string PrintData(lldb::addr_t addr, llvm::Type *type)
Definition: IRInterpreter.cpp:387
Module.h
InterpreterStackFrame::m_prev_bb
const BasicBlock * m_prev_bb
Definition: IRInterpreter.cpp:99
InterpreterStackFrame::Malloc
lldb::addr_t Malloc(size_t size, uint8_t byte_alignment)
Definition: IRInterpreter.cpp:367
lldb_private::EvaluateExpressionOptions
Definition: Target.h:255
InterpreterStackFrame::Jump
void Jump(const BasicBlock *bb)
Definition: IRInterpreter.cpp:127
InterpreterStackFrame::SummarizeValue
std::string SummarizeValue(const Value *value)
Definition: IRInterpreter.cpp:134
InterpreterStackFrame::m_byte_order
lldb::ByteOrder m_byte_order
Definition: IRInterpreter.cpp:107
lldb_private::Scalar::UInt128
llvm::APInt UInt128(const llvm::APInt &fail_value) const
Definition: Scalar.cpp:350
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::IRExecutionUnit::FindSymbol
lldb::addr_t FindSymbol(ConstString name, bool &missing_weak)
Definition: IRExecutionUnit.cpp:947
interpreter_internal_error
static const char * interpreter_internal_error
Definition: IRInterpreter.cpp:438
InterpreterStackFrame::m_execution_unit
lldb_private::IRExecutionUnit & m_execution_unit
Definition: IRInterpreter.cpp:97
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
IRInterpreter.h
lldb_private::ExecutionContext::GetThreadPtr
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
Definition: ExecutionContext.h:398
lldb_private::ExecutionContext::GetProcessRef
Process & GetProcessRef() const
Returns a reference to the process object.
Definition: ExecutionContext.cpp:231
ABI.h
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::IRMemoryMap::Free
void Free(lldb::addr_t process_address, Status &error)
Definition: IRMemoryMap.cpp:446
InterpreterStackFrame::InterpreterStackFrame
InterpreterStackFrame(DataLayout &target_data, lldb_private::IRExecutionUnit &execution_unit, lldb::addr_t stack_frame_bottom, lldb::addr_t stack_frame_top)
Definition: IRInterpreter.cpp:110
InterpreterStackFrame::m_addr_byte_size
size_t m_addr_byte_size
Definition: IRInterpreter.cpp:108
Target.h
lldb_private::Value::GetScalar
const Scalar & GetScalar() const
Definition: Value.h:112
LIBLLDB_LOG_EXPRESSIONS
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
unsupported_opcode_error
static const char * unsupported_opcode_error
Definition: IRInterpreter.cpp:434
bad_value_error
static const char * bad_value_error
Definition: IRInterpreter.cpp:440
InterpreterStackFrame
Definition: IRInterpreter.cpp:91
InterpreterStackFrame::MakeArgument
bool MakeArgument(const Argument *value, uint64_t address)
Definition: IRInterpreter.cpp:310
IRInterpreter::CanInterpret
static bool CanInterpret(llvm::Module &module, llvm::Function &function, lldb_private::Status &error, const bool support_function_calls)
Definition: IRInterpreter.cpp:484
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::Scalar::ULongLong
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:334
infinite_loop_error
static const char * infinite_loop_error
Definition: IRInterpreter.cpp:446
Log.h
InterpreterStackFrame::m_values
ValueMap m_values
Definition: IRInterpreter.cpp:95
InterpreterStackFrame::m_ie
BasicBlock::const_iterator m_ie
Definition: IRInterpreter.cpp:101
lldb_private::Scalar::SLongLong
long long SLongLong(long long fail_value=0) const
Definition: Scalar.cpp:330
InterpreterStackFrame::ResolveConstantValue
bool ResolveConstantValue(APInt &value, const Constant *constant)
Definition: IRInterpreter.cpp:231
lldb::eExpressionCompleted
@ eExpressionCompleted
Definition: lldb-enumerations.h:271
StreamString.h
CanIgnoreCall
static bool CanIgnoreCall(const CallInst *call)
Definition: IRInterpreter.cpp:72
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::StreamString
Definition: StreamString.h:23
InterpreterStackFrame::EvaluateValue
bool EvaluateValue(lldb_private::Scalar &scalar, const Value *value, Module &module)
Definition: IRInterpreter.cpp:164
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
InterpreterStackFrame::m_ii
BasicBlock::const_iterator m_ii
Definition: IRInterpreter.cpp:100
PrintType
static std::string PrintType(const Type *type, bool truncate=false)
Definition: IRInterpreter.cpp:62
IRExecutionUnit.h
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:38
memory_read_error
static const char * memory_read_error
Definition: IRInterpreter.cpp:445
PrintValue
static std::string PrintValue(const Value *value, bool truncate=false)
Definition: IRInterpreter.cpp:45
Thread.h
IRInterpreter::Interpret
static bool Interpret(llvm::Module &module, llvm::Function &function, llvm::ArrayRef< lldb::addr_t > args, lldb_private::IRExecutionUnit &execution_unit, lldb_private::Status &error, lldb::addr_t stack_frame_bottom, lldb::addr_t stack_frame_top, lldb_private::ExecutionContext &exe_ctx)
Definition: IRInterpreter.cpp:633
ValueObject.h
lldb_private::Scalar::MakeUnsigned
bool MakeUnsigned()
Definition: Scalar.cpp:259
lldb_private::IRMemoryMap::ReadMemory
void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size, Status &error)
Definition: IRMemoryMap.cpp:624
ThreadPlan.h
lldb_private::ExecutionContext::GetThreadRef
Thread & GetThreadRef() const
Returns a reference to the thread object.
Definition: ExecutionContext.cpp:236
unsupported_operand_error
static const char * unsupported_operand_error
Definition: IRInterpreter.cpp:436
lldb_private::Status
Definition: Status.h:44
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::ABI::CallArgument
Definition: ABI.h:28
lldb_private::IRMemoryMap::WriteMemory
void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes, size_t size, Status &error)
Definition: IRMemoryMap.cpp:513
lldb_private::Scalar::IsZero
bool IsZero() const
Definition: Scalar.cpp:143
uint32_t
InterpreterStackFrame::AssignValue
bool AssignValue(const Value *value, lldb_private::Scalar scalar, Module &module)
Definition: IRInterpreter.cpp:199
InterpreterStackFrame::m_bb
const BasicBlock * m_bb
Definition: IRInterpreter.cpp:98
lldb_private::Address
Definition: Address.h:59
lldb_private::DataExtractor::GetMaxU64
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:527
ThreadPlanCallFunctionUsingABI.h
lldb_private::IRMemoryMap::GetMemoryData
void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address, size_t size, Status &error)
Definition: IRMemoryMap.cpp:780
lldb_private::Scalar::ShiftRightLogical
bool ShiftRightLogical(const Scalar &rhs)
Definition: Scalar.cpp:433
lldb_private::DiagnosticManager
Definition: DiagnosticManager.h:93
lldb_private::ABI::CallArgument::value
lldb::addr_t value
Definition: ABI.h:36
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
lldb_private::ABI::CallArgument::HostPointer
@ HostPointer
Definition: ABI.h:30
DataExtractor.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::IRMemoryMap::WritePointerToMemory
void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t address, Status &error)
Definition: IRMemoryMap.cpp:615
InterpreterStackFrame::~InterpreterStackFrame
~InterpreterStackFrame()
Definition: IRInterpreter.cpp:125
DiagnosticManager.h
Status.h
InterpreterStackFrame::ResolveConstant
bool ResolveConstant(lldb::addr_t process_address, const Constant *constant)
Definition: IRInterpreter.cpp:342
lldb_private::ABI::CallArgument::size
size_t size
Definition: ABI.h:34
lldb::eByteOrderBig
@ eByteOrderBig
Definition: lldb-enumerations.h:140
lldb_private::Scalar::MakeSigned
bool MakeSigned()
Definition: Scalar.cpp:241
lldb_private::Status::Clear
void Clear()
Clear the object state.
Definition: Status.cpp:168
InterpreterStackFrame::m_target_data
DataLayout & m_target_data
Definition: IRInterpreter.cpp:96
ConstString.h
lldb_private::IRMemoryMap::ReadPointerFromMemory
void ReadPointerFromMemory(lldb::addr_t *address, lldb::addr_t process_address, Status &error)
Definition: IRMemoryMap.cpp:763
lldb_private::IRMemoryMap::GetAllocSize
bool GetAllocSize(lldb::addr_t address, size_t &size)
Definition: IRMemoryMap.cpp:491
lldb_private::Log
Definition: Log.h:49
InterpreterStackFrame::m_stack_pointer
lldb::addr_t m_stack_pointer
Definition: IRInterpreter.cpp:105
memory_write_error
static const char * memory_write_error
Definition: IRInterpreter.cpp:444
lldb_private::Process::RunThreadPlan
lldb::ExpressionResults RunThreadPlan(ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp, const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager)
Definition: Process.cpp:4620
lldb::eByteOrderLittle
@ eByteOrderLittle
Definition: lldb-enumerations.h:142
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
InterpreterStackFrame::AssignToMatchType
bool AssignToMatchType(lldb_private::Scalar &scalar, llvm::APInt value, Type *type)
Definition: IRInterpreter.cpp:150
Endian.h
CanResolveConstant
static bool CanResolveConstant(llvm::Constant *constant)
Definition: IRInterpreter.cpp:450
lldb_private::ABI::CallArgument::data_up
std::unique_ptr< uint8_t[]> data_up
Definition: ABI.h:37
ExecutionContext.h
lldb::ByteOrder
ByteOrder
Byte ordering definitions.
Definition: lldb-enumerations.h:138