docs: def dbg_print_stack(self, depth=None, sp=None):
          """
          Only used for debugging purposes.
          Return the current stack info in formatted string. If depth is None, the
          current stack frame (from sp to bp) will be printed out.
          """
  
          var_size = self.arch.bytes
          sp_sim = self.regs._sp
          bp_sim = self.regs._bp
          if self.solver.symbolic(sp_sim) and sp is None:
              result = "SP is SYMBOLIC"
          elif self.solver.symbolic(bp_sim) and depth is None:
              result = "BP is SYMBOLIC"
          else:
              sp_value = sp if sp is not None else self.solver.eval(sp_sim)
              if self.solver.symbolic(bp_sim):
                  result = "SP = 0x%08x, BP is symbolic\n" % (sp_value)
                  bp_value = None
              else:
                  bp_value = self.solver.eval(bp_sim)
                  result = "SP = 0x%08x, BP = 0x%08x\n" % (sp_value, bp_value)
              if depth is None:
                  # bp_value cannot be None here
                  depth = (bp_value - sp_value) // var_size + 1 # Print one more value
              pointer_value = sp_value
              for i in range(depth):
                  # For AbstractMemory, we wanna utilize more information from VSA
                  stack_values = [ ]
  
                  if o.ABSTRACT_MEMORY in self.options:
                      sp = self.regs._sp
                      segment_sizes = self.memory.get_segments(sp + i * var_size, var_size)
  
                      pos = i * var_size
                      for segment_size in segment_sizes:
                          stack_values.append(self.stack_read(pos, segment_size, bp=False))
                          pos += segment_size
                  else:
                      stack_values.append(self.stack_read(i * var_size, var_size, bp=False))
  
                  # Convert it into a big string!
                  val = self._stack_values_to_string(stack_values)
  
                  if pointer_value == sp_value:
                      line = "(sp)% 16x | %s" % (pointer_value, val)
                  elif pointer_value == bp_value:
                      line = "(bp)% 16x | %s" % (pointer_value, val)
                  else:
                      line = "% 20x | %s" % (pointer_value, val)
  
                  pointer_value += var_size
                  result += line + "\n"
          return result