openmp/libompd/src/TargetValue.cpp

/*
 * TargetValue.cpp -- Access to target values using OMPD callbacks
 */

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "TargetValue.h"
#include "Debug.h"
#include <cstring>
#include <fstream>
#include <iostream>
#include <sstream>

const ompd_callbacks_t *TValue::callbacks = NULL;
ompd_device_type_sizes_t TValue::type_sizes;

inline int ompd_sizeof(ompd_target_prim_types_t t) {
  assert(t != ompd_type_max && "ompd_type_max should not be used anywhere");
  assert(t != ompd_type_invalid && "request size of invalid type");

  return (((char *)&TValue::type_sizes)[(int)t]);
}

TType &TTypeFactory::getType(ompd_address_space_context_t *context,
                             const char *typeName, ompd_addr_t segment) {
  TType empty(true);

  if (ttypes.find(context) == ttypes.end()) {
    std::map<const char *, TType> empty;
    ttypes[context] = empty;
  }

  auto t = ttypes.find(context);
  auto i = t->second.find(typeName);
  if (i == t->second.end())
    i = t->second.insert(
        i, std::make_pair(typeName, TType(context, typeName, segment)));
  else
    i->second.context = context;

  return i->second;
}

TType::TType(ompd_address_space_context_t *_context, const char *_typeName,
             ompd_addr_t _segment)
    : typeSize(0), fieldOffsets(), descSegment(_segment), typeName(_typeName),
      context(_context), isvoid(false) {}

ompd_rc_t TType::getSize(ompd_size_t *size) {
  ompd_rc_t ret = ompd_rc_ok;
  if (typeSize == 0) {
    ompd_address_t symbolAddr;
    ompd_size_t tmpSize;
    std::stringstream ss;
    ss << "ompd_sizeof__" << typeName;

    ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
                                                &symbolAddr, NULL);
    if (ret != ompd_rc_ok) {
      dout << "missing symbol " << ss.str()
           << " add this to ompd-specific.h:\nOMPD_SIZEOF(" << typeName
           << ") \\" << std::endl;
      return ret;
    }

    symbolAddr.segment = descSegment;

    ret = TValue::callbacks->read_memory(
        context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
        &(tmpSize));
    if (ret != ompd_rc_ok)
      return ret;
    ret = TValue::callbacks->device_to_host(
        context, &tmpSize, TValue::type_sizes.sizeof_long_long, 1, &(typeSize));
  }
  *size = typeSize;
  return ret;
}

ompd_rc_t TType::getBitfieldMask(const char *fieldName,
                                 uint64_t *bitfieldmask) {
  ompd_rc_t ret = ompd_rc_ok;
  auto i = bitfieldMasks.find(fieldName);
  if (i == bitfieldMasks.end()) {
    uint64_t tmpMask, bitfieldMask;
    ompd_address_t symbolAddr;
    std::stringstream ss;
    ss << "ompd_bitfield__" << typeName << "__" << fieldName;
    ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
                                                &symbolAddr, NULL);
    if (ret != ompd_rc_ok) {
      dout << "missing symbol " << ss.str()
           << " add this to ompd-specific.h:\nOMPD_BITFIELD(" << typeName << ","
           << fieldName << ") \\" << std::endl;
      return ret;
    }
    symbolAddr.segment = descSegment;

    ret = TValue::callbacks->read_memory(
        context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
        &(tmpMask));
    if (ret != ompd_rc_ok)
      return ret;
    ret = TValue::callbacks->device_to_host(context, &(tmpMask),
                                            TValue::type_sizes.sizeof_long_long,
                                            1, &(bitfieldMask));
    if (ret != ompd_rc_ok) {
      return ret;
    }
    i = bitfieldMasks.insert(i, std::make_pair(fieldName, bitfieldMask));
  }
  *bitfieldmask = i->second;
  return ret;
}

ompd_rc_t TType::getElementOffset(const char *fieldName, ompd_size_t *offset) {
  ompd_rc_t ret = ompd_rc_ok;
  auto i = fieldOffsets.find(fieldName);
  if (i == fieldOffsets.end()) {
    ompd_size_t tmpOffset, fieldOffset;
    ompd_address_t symbolAddr;
    std::stringstream ss;
    ss << "ompd_access__" << typeName << "__" << fieldName;

    ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
                                                &symbolAddr, NULL);
    if (ret != ompd_rc_ok) {
      dout << "missing symbol " << ss.str()
           << " add this to ompd-specific.h:\nOMPD_ACCESS(" << typeName << ","
           << fieldName << ") \\" << std::endl;
      return ret;
    }
    symbolAddr.segment = descSegment;

    ret = TValue::callbacks->read_memory(
        context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
        &(tmpOffset));
    if (ret != ompd_rc_ok)
      return ret;
    ret = TValue::callbacks->device_to_host(context, &(tmpOffset),
                                            TValue::type_sizes.sizeof_long_long,
                                            1, &fieldOffset);
    if (ret != ompd_rc_ok) {
      return ret;
    }
    i = fieldOffsets.insert(i, std::make_pair(fieldName, fieldOffset));
  }
  *offset = i->second;
  return ret;
}

ompd_rc_t TType::getElementSize(const char *fieldName, ompd_size_t *size) {
  ompd_rc_t ret = ompd_rc_ok;
  auto i = fieldSizes.find(fieldName);
  if (i == fieldSizes.end()) {
    ompd_size_t tmpOffset, fieldSize;
    ompd_address_t symbolAddr;
    std::stringstream ss;
    ss << "ompd_sizeof__" << typeName << "__" << fieldName;

    ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
                                                &symbolAddr, NULL);
    if (ret != ompd_rc_ok) {
      dout << "missing symbol " << ss.str()
           << " add this to ompd-specific.h:\nOMPD_ACCESS(" << typeName << ","
           << fieldName << ") \\" << std::endl;
      return ret;
    }
    symbolAddr.segment = descSegment;

    ret = TValue::callbacks->read_memory(
        context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
        &(tmpOffset));
    if (ret != ompd_rc_ok)
      return ret;
    ret = TValue::callbacks->device_to_host(context, &tmpOffset,
                                            TValue::type_sizes.sizeof_long_long,
                                            1, &fieldSize);
    if (ret != ompd_rc_ok) {
      return ret;
    }
    i = fieldSizes.insert(i, std::make_pair(fieldName, fieldSize));
  }
  *size = i->second;
  return ret;
}

TValue::TValue(ompd_address_space_context_t *_context,
               ompd_thread_context_t *_tcontext, const char *_valueName,
               ompd_addr_t segment)
    : errorState(ompd_rc_ok), type(&nullType), pointerLevel(0),
      context(_context), tcontext(_tcontext), fieldSize(0) {
  errorState.errorCode = callbacks->symbol_addr_lookup(
      context, tcontext, _valueName, &symbolAddr, NULL);
  symbolAddr.segment = segment;
}

TValue::TValue(ompd_address_space_context_t *_context,
               ompd_thread_context_t *_tcontext, ompd_address_t addr)
    : errorState(ompd_rc_ok), type(&nullType), pointerLevel(0),
      context(_context), tcontext(_tcontext), symbolAddr(addr), fieldSize(0) {
  if (addr.address == 0)
    errorState.errorCode = ompd_rc_bad_input;
}

TValue &TValue::cast(const char *typeName) {
  if (gotError())
    return *this;
  type = &tf.getType(context, typeName, symbolAddr.segment);
  pointerLevel = 0;
  assert(!type->isVoid() && "cast to invalid type failed");
  return *this;
}

TValue &TValue::cast(const char *typeName, int _pointerLevel,
                     ompd_addr_t segment) {
  if (gotError())
    return *this;
  type = &tf.getType(context, typeName, symbolAddr.segment);
  pointerLevel = _pointerLevel;
  symbolAddr.segment = segment;
  assert(!type->isVoid() && "cast to invalid type failed");
  return *this;
}

TValue TValue::dereference() const {
  if (gotError())
    return *this;
  ompd_address_t tmpAddr;
  assert(!type->isVoid() && "cannot work with void");
  assert(pointerLevel > 0 && "cannot dereference non-pointer");
  TValue ret = *this;
  ret.pointerLevel--;
  ret.errorState.errorCode = callbacks->read_memory(
      context, tcontext, &symbolAddr, 1 * TValue::type_sizes.sizeof_pointer,
      &(tmpAddr.address));
  if (ret.errorState.errorCode != ompd_rc_ok)
    return ret;

  ret.errorState.errorCode = callbacks->device_to_host(
      context, &(tmpAddr.address), TValue::type_sizes.sizeof_pointer, 1,
      &(ret.symbolAddr.address));
  if (ret.errorState.errorCode != ompd_rc_ok) {
    return ret;
  }
  if (ret.symbolAddr.address == 0)
    ret.errorState.errorCode = ompd_rc_unsupported;
  return ret;
}

ompd_rc_t TValue::getAddress(ompd_address_t *addr) const {
  *addr = symbolAddr;
  if (symbolAddr.address == 0)
    return ompd_rc_unsupported;
  return errorState.errorCode;
}

ompd_rc_t TValue::getRawValue(void *buf, int count) {
  if (errorState.errorCode != ompd_rc_ok)
    return errorState.errorCode;
  ompd_size_t size;
  errorState.errorCode = type->getSize(&size);
  if (errorState.errorCode != ompd_rc_ok)
    return errorState.errorCode;

  errorState.errorCode =
      callbacks->read_memory(context, tcontext, &symbolAddr, size, buf);
  return errorState.errorCode;
}

ompd_rc_t TValue::getString(const char **buf) {
  *buf = 0;
  if (gotError())
    return getError();

  TValue strValue = dereference();
  if (strValue.gotError()) {
    return strValue.getError();
  }

  if (!callbacks) {
    return ompd_rc_error;
  }
  ompd_rc_t ret;
#define BUF_LEN 512
  char *string_buffer;

  // Allocate an extra byte, but pass only BUF_LEN to the tool
  // so that we can detect truncation later.
  ret = callbacks->alloc_memory(BUF_LEN + 1, (void **)&string_buffer);
  if (ret != ompd_rc_ok) {
    return ret;
  }
  string_buffer[BUF_LEN] = '\0';

  // TODO: if we have not read in the complete string, we need to realloc
  // 'string_buffer' and attempt reading again repeatedly till the entire string
  // is read in.
  ret = callbacks->read_string(context, tcontext, &strValue.symbolAddr, BUF_LEN,
                               (void *)string_buffer);
  *buf = string_buffer;
  // Check for truncation. The standard specifies that if a null byte is not
  // among the first 'nbytes' bytes, the string placed in the buffer is not
  // null-terminated. 'nbytes' is BUF_LEN in this case.
  if (ret == ompd_rc_ok && strlen(string_buffer) == BUF_LEN) {
    return ompd_rc_error;
  }
  return ret;
}

TBaseValue TValue::castBase(const char *varName) {
  ompd_size_t size;
  errorState.errorCode =
      tf.getType(context, varName, symbolAddr.segment).getSize(&size);
  return TBaseValue(*this, size);
}

TBaseValue TValue::castBase() const {
  if (pointerLevel > 0)
    return TBaseValue(*this, type_sizes.sizeof_pointer);
  return TBaseValue(*this, fieldSize);
}

TBaseValue TValue::castBase(ompd_target_prim_types_t baseType) const {
  return TBaseValue(*this, baseType);
}

TValue TValue::access(const char *fieldName) const {
  if (gotError())
    return *this;
  TValue ret = *this;
  assert(pointerLevel < 2 && "access to field element of pointer array failed");
  if (pointerLevel == 1) // -> operator
    ret = ret.dereference();
  // we use *this for . operator
  ompd_size_t offset;
  ret.errorState.errorCode = type->getElementOffset(fieldName, &offset);
  ret.errorState.errorCode = type->getElementSize(fieldName, &(ret.fieldSize));
  ret.symbolAddr.address += offset;

  return ret;
}

ompd_rc_t TValue::check(const char *bitfieldName, ompd_word_t *isSet) const {
  if (gotError())
    return getError();
  int bitfield;
  uint64_t bitfieldmask;
  ompd_rc_t ret = this->castBase(ompd_type_int).getValue(&bitfield, 1);
  if (ret != ompd_rc_ok)
    return ret;
  ret = type->getBitfieldMask(bitfieldName, &bitfieldmask);
  *isSet = ((bitfield & bitfieldmask) != 0);
  return ret;
}

TValue TValue::getArrayElement(int elemNumber) const {
  if (gotError())
    return *this;
  TValue ret;
  if (pointerLevel > 0) {
    ret = dereference();
  } else {
    ret = *this;
  }
  if (ret.pointerLevel == 0) {
    ompd_size_t size;
    ret.errorState.errorCode = type->getSize(&size);
    ret.symbolAddr.address += elemNumber * size;
  } else {
    ret.symbolAddr.address += elemNumber * type_sizes.sizeof_pointer;
  }
  return ret;
}

TValue TValue::getPtrArrayElement(int elemNumber) const {
  if (gotError()) {
    return *this;
  }
  assert(pointerLevel > 0 && "This only works on arrays of pointers");
  TValue ret = *this;
  ret.symbolAddr.address += elemNumber * type_sizes.sizeof_pointer;
  return ret;
}

TBaseValue::TBaseValue(const TValue &_tvalue,
                       ompd_target_prim_types_t _baseType)
    : TValue(_tvalue), baseTypeSize(ompd_sizeof(_baseType)) {}
TBaseValue::TBaseValue(const TValue &_tvalue, ompd_size_t _baseTypeSize)
    : TValue(_tvalue), baseTypeSize(_baseTypeSize) {}

ompd_rc_t TBaseValue::getValue(void *buf, int count) {
  if (errorState.errorCode != ompd_rc_ok)
    return errorState.errorCode;
  errorState.errorCode = callbacks->read_memory(context, tcontext, &symbolAddr,
                                                count * baseTypeSize, buf);
  if (errorState.errorCode != ompd_rc_ok)
    return errorState.errorCode;
  errorState.errorCode =
      callbacks->device_to_host(context, buf, baseTypeSize, count, buf);
  return errorState.errorCode;
}