Location.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2000-2005, 2018-2021, 2023, 2026 Carlo Wood
// SPDX-License-Identifier: MIT
 
#pragma once

 
#ifndef LIBCWD_CLASS_LOCATION_H
#define LIBCWD_CLASS_LOCATION_H
 
#include "libcwd/config.h"
 
#if CWDEBUG_LOCATION
 
#include "ObjectFileName.h"
#include "lockable_auto_ptr.h"
#include "private/ThreadSpecificData.h"
 
#include <cstring>
#include <iosfwd>
#include <string>
 
namespace libcwd {
 
// Forward declaration.
class Location;
 
namespace _private_ {
 
// Forward declaration.
template <class OSTREAM>
void print_location_on(OSTREAM& os, Location const& location);
 
} // namespace _private_
} // namespace libcwd
 
namespace libcwd {


extern char const* const unknown_function_c;

class Location
{
 protected:
  ObjectFileName const* object_file_name_; 
  char const* function_name_; 
  lockable_auto_ptr<char, true>
      filepath_; 
  union
  {
    char const* filename_; 
    void const* initialization_delayed_; 
    void const* unknown_pc_; 
  };
  unsigned int line_; 
  bool known_; 
 private:
 protected:
  // function_name_ can point to one of these constants, or to libcwd::unknown_function_c
  // or to a static string with the mangled function name.
  static char const uninitialized_location[];
  static char const pre_libcwd_initialization[];
  static char const cleared_location[];
 
 public:
  explicit Location(void const* addr);
  // Construct a location object for address `addr'.
  explicit Location(void const* addr, LIBCWD_TSD_PARAM);
  // Idem, but with passing the TSD.
  ~Location();

  Location();

  Location(Location const& location);

  Location& operator=(Location const& location); // Assignment operator

  void lock_ownership()
  {
    if (known_)
      filepath_.lock();
  }

  void pc_location(void const* pc);
 
  // Only public because libcwd calls it directly.
  void pc_location(void const* pc, LIBCWD_TSD_PARAM);

  void clear();
 
 public:
  // Accessors
  bool is_known() const;

  std::string file() const;

  unsigned int line() const;

  char const* mangled_function_name() const;

  size_t filename_length() const { return known_ ? std::strlen(filename_) : 0; }
  size_t filepath_length() const { return known_ ? std::strlen(filepath_.get()) : 0; }

  ObjectFileName const* object_file() const { return object_file_name_; }
 
  // Printing
  void print_filepath_on(std::ostream& os) const;
  void print_filename_on(std::ostream& os) const;
  template <class OSTREAM>
  friend void _private_::print_location_on(OSTREAM& os, Location const& location);
#if (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
  // This doesn't need to be a friend, but g++ 3.3.x and lower are broken.
  // We need to declare an operator<< this way as a workaround.
  friend std::ostream& operator<<(std::ostream& os, Location const& location)
  {
    _private_::print_location_on(os, location);
    return os;
  }
#endif
 
  // Return the program counter that still needs lazy symbol resolution, if any.
  bool initialization_delayed() const { return (!object_file_name_ && function_name_ == pre_libcwd_initialization); }
  void const* unknown_pc() const
  {
    return (!object_file_name_ && function_name_ == unknown_function_c) ? unknown_pc_
           : initialization_delayed()                                   ? initialization_delayed_
                                                                        : 0;
  }
};
 
// #if (__GNUC__ > 3 || __GNUC_MINOR__ >= 4)
// extern std::ostream& operator<<(std::ostream& os, Location const& location);
// #endif

location_format_t location_format(location_format_t format);
 // End of group 'source-file-line-number-information'
 
} // namespace libcwd
 
#endif // CWDEBUG_LOCATION
#endif // LIBCWD_CLASS_LOCATION_H