17187640060

Committed 24 Aug 2025 10:37AM UTC coverage: 82.235% (-1.1%) from 83.355%

Build # 17187640060

Build Type

Pull #45

github

Committed by

web-flow

Commit Message

Merge c44adfdd0 into c60847ea6

Pull Request Pull Request #45: Disable TBAA for all cases

Run Details

1229 of 1781 branches covered (69.01%)

Branch coverage included in aggregate %.

205 of 211 new or added lines in 7 files covered. (97.16%)

48 existing lines in 5 files now uncovered.

2215 of 2407 relevant lines covered (92.02%)

7609.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.0

/lib/type/TBAA.cpp

//  llvm-dimeta library
//  Copyright (c) 2022-2025 llvm-dimeta authors
//  Distributed under the BSD 3-Clause license.
//  (See accompanying file LICENSE)
//  SPDX-License-Identifier: BSD-3-Clause
//

#include "TBAA.h"

#include "DIUtil.h"
#include "DIVisitor.h"
#include "support/Logger.h"

#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Metadata.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/raw_ostream.h"

#include <cassert>
#include <cstddef>
#include <iterator>
#include <llvm/ADT/STLExtras.h>
#include <llvm/ADT/SmallVector.h>
#include <llvm/Support/GlobPattern.h>
#include <optional>
#include <string>
#include <utility>

namespace dimeta::tbaa {

struct TBAAHandle {
  llvm::MDNode* base_ty;
  llvm::MDNode* access_ty;
  llvm::ConstantInt* offset;
  size_t offset_value{};

  static std::optional<TBAAHandle> create(const llvm::Instruction& store) {
    auto* access = store.getMetadata(llvm::StringRef{"tbaa"});
    if (!access) {
      return {};
    }

    std::optional<llvm::GlobPattern> glob_pointer_pattern = []() -> std::optional<llvm::GlobPattern> {
#if LLVM_VERSION_MAJOR > 18
      auto pattern = llvm::GlobPattern::create("p[1-9] *");
      if (pattern) {
        return pattern.get();
      }
      LOG_WARNING("Glob pattern to match TBAA strings failed.")
#endif
      return std::nullopt;
    }();

    return TBAAHandle(*access, glob_pointer_pattern);
  }

  llvm::StringRef base_name() const {
    return llvm::dyn_cast<llvm::MDString>(base_ty->getOperand(0))->getString();
  }

  llvm::StringRef access_name() const {
    return llvm::dyn_cast<llvm::MDString>(access_ty->getOperand(0))->getString();
  }

  bool access_is_ptr() const {
    return check_if_pointer_type(access_name());
  }

  bool base_is_ptr() const {
    return check_if_pointer_type(base_name());
  }
  void reset_base(llvm::MDNode* new_base_ty) {
    LOG_DEBUG("Reset base_type " << log::ditype_str(base_ty) << " to " << log::ditype_str(new_base_ty))
    base_ty = new_base_ty;
  }

  void subtract_offset(size_t offset_) {
    LOG_DEBUG("Reset offset value " << offset_value << " with subtraction of " << offset_)
    assert(offset_ <= offset_value && "New offset should not be greater than current one");
    offset_value -= offset_;
  }

 private:
  explicit TBAAHandle(llvm::MDNode& tbaa_node, std::optional<llvm::GlobPattern> pattern)
      : glob_pointer_pattern_(std::move(pattern)) {
    base_ty        = llvm::dyn_cast<llvm::MDNode>(tbaa_node.getOperand(0));
    access_ty      = llvm::dyn_cast<llvm::MDNode>(tbaa_node.getOperand(1));
    auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(tbaa_node.getOperand(2))->getValue();
    assert(value_md && "Offset value may not be null.");
    offset       = llvm::dyn_cast<llvm::ConstantInt>(value_md);
    offset_value = offset->getLimitedValue();
  }

  bool check_if_pointer_type(llvm::StringRef name) const {
    bool matches_glob = false;
#if LLVM_VERSION_MAJOR > 18
    if (glob_pointer_pattern_) {
      // Corrected: assign to matches_glob
      matches_glob = glob_pointer_pattern_->match(name);
    }
#endif
    return name == "any pointer" || matches_glob;
  }

  std::optional<llvm::GlobPattern> glob_pointer_pattern_;
};

namespace helper {

class FindMatchingMember : public visitor::DINodeVisitor<FindMatchingMember> {
  llvm::StringRef composite_name_;

 public:
  std::optional<llvm::DICompositeType*> result{};
  explicit FindMatchingMember(llvm::StringRef composite_name) : composite_name_(composite_name) {
  }

  bool visitCompositeType(const llvm::DICompositeType* type) {
    const auto id = [](const auto* type) -> llvm::StringRef {
      if (type->getIdentifier().empty()) {
        return type->getName();
      }
      return type->getIdentifier();
    }(type);

    if (id == composite_name_) {
      result = const_cast<llvm::DICompositeType*>(type);
      return false;
    }

    return true;
  }
};

std::optional<llvm::DICompositeType*> find_composite_with_name(llvm::StringRef composite_name,
                                                               const llvm::DICompositeType* type) {
  FindMatchingMember finder{composite_name};
  finder.traverseCompositeType(type);
  return finder.result;
}

inline size_t tbaa_operand_count(llvm::MDNode* type_node) {
  // Given, e.g., {!"_ZTSNSt12_Vector_baseIPiSaIS0_EE17_Vector_impl_dataE", !749, i64 0, !749, i64 8, !749, i64 16}
  // returns number of [type, offsets] pairs: 3
  const auto num = type_node->getNumOperands();
  assert(num > 0 && "Operand count must be > 0");
  return (num - 1) / 2;
}

inline std::optional<llvm::StringRef> tbaa_operand_name(llvm::MDNode* type_node) {
  if (type_node->getNumOperands() == 0) {
    return {};
  }
  return llvm::dyn_cast<llvm::MDString>(type_node->getOperand(0))->getString();
}

struct TBAADestructure {
  llvm::StringRef name;
  size_t offset_base_{};
  std::optional<llvm::MDNode*> outermost_candidate_{};

  bool traverse_tbaa_nodes(llvm::MDNode* new_base_ty) {
    const auto tbaa_name = tbaa_operand_name(new_base_ty).value_or("");
    if (!tbaa_name.empty() && name == tbaa_name) {
      LOG_DEBUG("Match found " << log::ditype_str(new_base_ty))
      outermost_candidate_.emplace(new_base_ty);
      return true;
    }

    const auto* end_node = std::prev(new_base_ty->op_end());
    for (const auto* iter = new_base_ty->op_begin(); iter != end_node; ++iter) {
      const auto& operand = *iter;

      if (auto* mdnode = llvm::dyn_cast<llvm::MDNode>(operand)) {
        auto result = traverse_tbaa_nodes(mdnode);

        if (result) {
          // we found a matching node, we need to set the offset now to re-calculate later
          const auto* offset = std::next(iter);
          if (auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(*offset)) {
            if (auto* current_offset = llvm::dyn_cast<llvm::ConstantInt>(value_md->getValue())) {
              this->offset_base_ += current_offset->getLimitedValue();
            }
          }
          break;
        }
      }
    }

    return false;
  }
};

inline std::pair<std::optional<llvm::MDNode*>, size_t> tbaa_sub_node_matches_name(llvm::StringRef name,
                                                                                  llvm::MDNode* new_base_ty) {
  TBAADestructure tbaa{name};
  tbaa.traverse_tbaa_nodes(new_base_ty);
  LOG_DEBUG("Found " << log::ditype_str(tbaa.outermost_candidate_.value_or(nullptr)) << " at offset "
                     << tbaa.offset_base_)
  return {tbaa.outermost_candidate_, tbaa.offset_base_};
}

}  // namespace helper

bool composite_fits_tbaa(const llvm::DICompositeType* composite, const TBAAHandle& tbaa) {
  assert(composite != nullptr);
  const auto num_members = di::util::get_num_composite_members(*composite);
  const auto tbaa_count  = helper::tbaa_operand_count(tbaa.base_ty);
  if (num_members != tbaa_count) {
    return false;
  }

  LOG_DEBUG("Type element size " << num_members << " vs. TBAA " << tbaa_count)

  const auto elements     = di::util::get_composite_members(*composite);
  size_t element_position = 0;  // Incremented for every TBAA constant int entry
  // Loop simply checks if the byte offsets are the same (TODO also compare types!)
  for (const auto& tbaa_operand : tbaa.base_ty->operands()) {
    if (auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(tbaa_operand)) {
      if (auto* current_offset = llvm::dyn_cast<llvm::ConstantInt>(value_md->getValue())) {
        auto* current_member = elements[element_position];
        if (!current_offset->equalsInt(current_member->getOffsetInBits() / 8)) {
          return false;
        }
        ++element_position;
      }
    }
  }

  return true;
}

std::optional<llvm::DIType*> tbaa_resolver(llvm::DIType* root, TBAAHandle& tbaa) {
  const auto find_composite = [](llvm::DIType* root) {
    llvm::DIType* type = root;
    while (type && llvm::isa<llvm::DIDerivedType>(type)) {
      auto ditype = llvm::dyn_cast<llvm::DIDerivedType>(type);
      type        = ditype->getBaseType();
    }
    return type;
  };

  auto* maybe_composite = find_composite(root);
  if (!maybe_composite || !llvm::isa<llvm::DICompositeType>(maybe_composite)) {
    LOG_DEBUG("Returning: DIType is not composite required for TBAA descend.")
    return root;
  }

  auto* composite = llvm::dyn_cast<llvm::DICompositeType>(maybe_composite);

  LOG_DEBUG("Found maybe legible composite node: " << log::ditype_str(composite))

  // Cpp TBAA uses identifier, in C we use the name:
  const auto struct_name = [](const auto* composite) {
    auto name = std::string{composite->getIdentifier()};
    if (name.empty()) {
      name = std::string{composite->getName()};
    }
    return name;
  }(composite);

  if (struct_name != tbaa.base_name() && !tbaa.base_name().empty()) {
    LOG_DEBUG("Names differ. Name of struct: \"" << struct_name << "\" vs name of TBAA \"" << tbaa.base_name() << "\".")
    auto result_composite = helper::find_composite_with_name(tbaa.base_name(), composite);

    if (result_composite) {
      LOG_DEBUG("Found matching sub member " << log::ditype_str(result_composite.value()))
      composite = result_composite.value();  // const_cast<llvm::DICompositeType*>(result_composite.value());
      const auto num_members = di::util::get_num_composite_members(*composite);
      const auto num_tbaa    = helper::tbaa_operand_count(tbaa.base_ty);
      if (num_members != num_tbaa) {
        LOG_DEBUG("Mismatch between sub member element count and TBAA base type count "
                  << log::ditype_str(tbaa.base_ty))
        return root;
      }
    } else {
      LOG_DEBUG("Did not find matching sub member: " << struct_name)
      const auto [new_base, calculated_offset] = helper::tbaa_sub_node_matches_name(struct_name, tbaa.base_ty);
      if (!new_base) {
        LOG_DEBUG("Did not find new base, returning")
        return root;
      }
      LOG_DEBUG("New TBAA base " << log::ditype_str(new_base.value()) << " with negative offset " << calculated_offset)
      tbaa.reset_base(new_base.value());
      tbaa.subtract_offset(calculated_offset);
    }
  }

  if (struct_name.empty()) {
    LOG_DEBUG("No name match possible")
    // Here no name matching is possible, is TBAA node referring to current DI type? We need to verify:
    if (!composite_fits_tbaa(composite, tbaa)) {
      LOG_DEBUG("TBAA of anonymous struct has different offsets to DIComposite type!")
      return root;
    }
  }

  assert(tbaa.access_is_ptr() && "TBAA access should be pointer");

  LOG_DEBUG("TBAA tree data.")
  LOG_DEBUG("  From ditype: " << log::ditype_str(composite))
  LOG_DEBUG("  From TBAA: " << log::ditype_str(tbaa.base_ty))
  LOG_DEBUG("  At offset: " << tbaa.offset_value)

  auto result = di::util::resolve_byte_offset_to_member_of(composite, tbaa.offset_value);
  if (result) {
    return result->type_of_member;
  }
  return {};
}

std::optional<llvm::DIType*> resolve_tbaa(llvm::DIType* root, const llvm::Instruction& instruction) {
  LOG_DEBUG("Resolve TBAA of instruction '" << instruction << "' with ditype: " << log::ditype_str(root))

  auto tbaa = TBAAHandle::create(instruction);
  if (!tbaa) {
    LOG_DEBUG("Requires TBAA metadata in LLVM IR.")
    return root;
  }

  // assign any ptr to any ptr, e.g., struct A** a; a[0] = malloc(struct A):
  if (tbaa->base_ty == tbaa->access_ty && tbaa->access_is_ptr()) {
    LOG_DEBUG("No work: TBAA base type is same as access type (both ptr).")
    return root;
  }

  const auto node = tbaa_resolver(root, tbaa.value());
  if (node.has_value() && node.value() != root) {
    LOG_DEBUG("Determined new type with TBAA")
  }

  return node;
}

}  // namespace dimeta::tbaa

1	// llvm-dimeta library
2	// Copyright (c) 2022-2025 llvm-dimeta authors
3	// Distributed under the BSD 3-Clause license.
4	// (See accompanying file LICENSE)
5	// SPDX-License-Identifier: BSD-3-Clause
6	//
7
8	#include "TBAA.h"
9
10	#include "DIUtil.h"
11	#include "DIVisitor.h"
12	#include "support/Logger.h"
13
14	#include "llvm/ADT/StringRef.h"
15	#include "llvm/BinaryFormat/Dwarf.h"
16	#include "llvm/IR/Constants.h"
17	#include "llvm/IR/DebugInfoMetadata.h"
18	#include "llvm/IR/Instruction.h"
19	#include "llvm/IR/Instructions.h"
20	#include "llvm/IR/Metadata.h"
21	#include "llvm/Support/Casting.h"
22	#include "llvm/Support/raw_ostream.h"
23
24	#include <cassert>
25	#include <cstddef>
26	#include <iterator>
27	#include <llvm/ADT/STLExtras.h>
28	#include <llvm/ADT/SmallVector.h>
29	#include <llvm/Support/GlobPattern.h>
30	#include <optional>
31	#include <string>
32	#include <utility>
33
34	namespace dimeta::tbaa {
35
36	struct TBAAHandle {
37	llvm::MDNode* base_ty;
38	llvm::MDNode* access_ty;
39	llvm::ConstantInt* offset;
40	size_t offset_value{};	716✔
41
42	static std::optional<TBAAHandle> create(const llvm::Instruction& store) {	726✔
43	auto* access = store.getMetadata(llvm::StringRef{"tbaa"});	726✔
44	if (!access) {	726✔
45	return {};	10✔
46	}
47
48	std::optional<llvm::GlobPattern> glob_pointer_pattern = []() -> std::optional<llvm::GlobPattern> {	1,432✔
49	#if LLVM_VERSION_MAJOR > 18
50	auto pattern = llvm::GlobPattern::create("p[1-9] *");	480✔
51	if (pattern) {	480!
52	return pattern.get();	480✔
53	}
54	LOG_WARNING("Glob pattern to match TBAA strings failed.")
55	#endif
56	return std::nullopt;	236✔
57	}();	480✔
58
59	return TBAAHandle(*access, glob_pointer_pattern);	716✔
60	}	726✔
61
62	llvm::StringRef base_name() const {	110✔
63	return llvm::dyn_cast<llvm::MDString>(base_ty->getOperand(0))->getString();	110✔
64	}
65
66	llvm::StringRef access_name() const {	470✔
67	return llvm::dyn_cast<llvm::MDString>(access_ty->getOperand(0))->getString();	470✔
68	}
69
70	bool access_is_ptr() const {	470✔
71	return check_if_pointer_type(access_name());	470✔
72	}
73
74	bool base_is_ptr() const {
75	return check_if_pointer_type(base_name());
76	}
UNCOV 77	void reset_base(llvm::MDNode* new_base_ty) {	×
78	LOG_DEBUG("Reset base_type " << log::ditype_str(base_ty) << " to " << log::ditype_str(new_base_ty))
UNCOV 79	base_ty = new_base_ty;	×
UNCOV 80	}	×
81
UNCOV 82	void subtract_offset(size_t offset_) {	×
83	LOG_DEBUG("Reset offset value " << offset_value << " with subtraction of " << offset_)
UNCOV 84	assert(offset_ <= offset_value && "New offset should not be greater than current one");	×
UNCOV 85	offset_value -= offset_;	×
UNCOV 86	}	×
87
88	private:
89	explicit TBAAHandle(llvm::MDNode& tbaa_node, std::optional<llvm::GlobPattern> pattern)	716✔
90	: glob_pointer_pattern_(std::move(pattern)) {	716✔
91	base_ty = llvm::dyn_cast<llvm::MDNode>(tbaa_node.getOperand(0));	716✔
92	access_ty = llvm::dyn_cast<llvm::MDNode>(tbaa_node.getOperand(1));	716✔
93	auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(tbaa_node.getOperand(2))->getValue();	716✔
94	assert(value_md && "Offset value may not be null.");	1,432!
95	offset = llvm::dyn_cast<llvm::ConstantInt>(value_md);	716✔
96	offset_value = offset->getLimitedValue();	716✔
97	}	716✔
98
99	bool check_if_pointer_type(llvm::StringRef name) const {	470✔
100	bool matches_glob = false;	470✔
101	#if LLVM_VERSION_MAJOR > 18
102	if (glob_pointer_pattern_) {	316!
103	// Corrected: assign to matches_glob
104	matches_glob = glob_pointer_pattern_->match(name);	316✔
105	}	316✔
106	#endif
107	return name == "any pointer" \|\| matches_glob;	470✔
108	}	470✔
109
110	std::optional<llvm::GlobPattern> glob_pointer_pattern_;
111	};
112
113	namespace helper {
114
115	class FindMatchingMember : public visitor::DINodeVisitor<FindMatchingMember> {
116	llvm::StringRef composite_name_;
117
118	public:
119	std::optional<llvm::DICompositeType*> result{};	18✔
120	explicit FindMatchingMember(llvm::StringRef composite_name) : composite_name_(composite_name) {	18✔
121	}	18✔
122
123	bool visitCompositeType(const llvm::DICompositeType* type) {	48✔
124	const auto id = [](const auto* type) -> llvm::StringRef {	144✔
125	if (type->getIdentifier().empty()) {	48!
UNCOV 126	return type->getName();	×
127	}
128	return type->getIdentifier();	48✔
129	}(type);	96✔
130
131	if (id == composite_name_) {	48✔
132	result = const_cast<llvm::DICompositeType*>(type);	6✔
133	return false;	6✔
134	}
135
136	return true;	42✔
137	}	48✔
138	};
139
140	std::optional<llvm::DICompositeType*> find_composite_with_name(llvm::StringRef composite_name,	18✔
141	const llvm::DICompositeType* type) {
142	FindMatchingMember finder{composite_name};	18✔
143	finder.traverseCompositeType(type);	18✔
144	return finder.result;	18✔
145	}	18✔
146
147	inline size_t tbaa_operand_count(llvm::MDNode* type_node) {	18✔
148	// Given, e.g., {!"_ZTSNSt12_Vector_baseIPiSaIS0_EE17_Vector_impl_dataE", !749, i64 0, !749, i64 8, !749, i64 16}
149	// returns number of [type, offsets] pairs: 3
150	const auto num = type_node->getNumOperands();	18✔
151	assert(num > 0 && "Operand count must be > 0");	36!
152	return (num - 1) / 2;	36✔
153	}	18✔
154
155	inline std::optional<llvm::StringRef> tbaa_operand_name(llvm::MDNode* type_node) {	92✔
156	if (type_node->getNumOperands() == 0) {	92!
157	return {};	×
158	}
159	return llvm::dyn_cast<llvm::MDString>(type_node->getOperand(0))->getString();	92✔
160	}	92✔
161
162	struct TBAADestructure {
163	llvm::StringRef name;
164	size_t offset_base_{};
165	std::optional<llvm::MDNode*> outermost_candidate_{};	12✔
166
167	bool traverse_tbaa_nodes(llvm::MDNode* new_base_ty) {	92✔
168	const auto tbaa_name = tbaa_operand_name(new_base_ty).value_or("");	92✔
169	if (!tbaa_name.empty() && name == tbaa_name) {	92!
170	LOG_DEBUG("Match found " << log::ditype_str(new_base_ty))
UNCOV 171	outermost_candidate_.emplace(new_base_ty);	×
UNCOV 172	return true;	×
173	}
174
175	const auto* end_node = std::prev(new_base_ty->op_end());	92✔
176	for (const auto* iter = new_base_ty->op_begin(); iter != end_node; ++iter) {	252✔
177	const auto& operand = *iter;	160✔
178
179	if (auto* mdnode = llvm::dyn_cast<llvm::MDNode>(operand)) {	240!
180	auto result = traverse_tbaa_nodes(mdnode);	80✔
181
182	if (result) {	80!
183	// we found a matching node, we need to set the offset now to re-calculate later
UNCOV 184	const auto* offset = std::next(iter);	×
UNCOV 185	if (auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(*offset)) {	×
UNCOV 186	if (auto* current_offset = llvm::dyn_cast<llvm::ConstantInt>(value_md->getValue())) {	×
UNCOV 187	this->offset_base_ += current_offset->getLimitedValue();	×
UNCOV 188	}	×
UNCOV 189	}	×
190	break;
UNCOV 191	}	×
192	}	80!
193	}	160!
194
195	return false;	92✔
196	}	92✔
197	};
198
199	inline std::pair<std::optional<llvm::MDNode*>, size_t> tbaa_sub_node_matches_name(llvm::StringRef name,	12✔
200	llvm::MDNode* new_base_ty) {
201	TBAADestructure tbaa{name};	12✔
202	tbaa.traverse_tbaa_nodes(new_base_ty);	12✔
203	LOG_DEBUG("Found " << log::ditype_str(tbaa.outermost_candidate_.value_or(nullptr)) << " at offset "
204	<< tbaa.offset_base_)
205	return {tbaa.outermost_candidate_, tbaa.offset_base_};	12✔
206	}	12✔
207
208	} // namespace helper
209
210	bool composite_fits_tbaa(const llvm::DICompositeType* composite, const TBAAHandle& tbaa) {	12✔
211	assert(composite != nullptr);	12!
212	const auto num_members = di::util::get_num_composite_members(*composite);	12✔
213	const auto tbaa_count = helper::tbaa_operand_count(tbaa.base_ty);	12✔
214	if (num_members != tbaa_count) {	12!
215	return false;	12✔
216	}
217
218	LOG_DEBUG("Type element size " << num_members << " vs. TBAA " << tbaa_count)
219
UNCOV 220	const auto elements = di::util::get_composite_members(*composite);	×
UNCOV 221	size_t element_position = 0; // Incremented for every TBAA constant int entry	×
222	// Loop simply checks if the byte offsets are the same (TODO also compare types!)
UNCOV 223	for (const auto& tbaa_operand : tbaa.base_ty->operands()) {	×
UNCOV 224	if (auto* value_md = llvm::dyn_cast<llvm::ValueAsMetadata>(tbaa_operand)) {	×
UNCOV 225	if (auto* current_offset = llvm::dyn_cast<llvm::ConstantInt>(value_md->getValue())) {	×
UNCOV 226	auto* current_member = elements[element_position];	×
UNCOV 227	if (!current_offset->equalsInt(current_member->getOffsetInBits() / 8)) {	×
228	return false;	×
229	}
UNCOV 230	++element_position;	×
UNCOV 231	}	×
UNCOV 232	}	×
UNCOV 233	}	×
234
UNCOV 235	return true;	×
236	}	12✔
237
238	std::optional<llvm::DIType> tbaa_resolver(llvm::DIType root, TBAAHandle& tbaa) {	284✔
239	const auto find_composite = [](llvm::DIType* root) {	568✔
240	llvm::DIType* type = root;	284✔
241	while (type && llvm::isa<llvm::DIDerivedType>(type)) {	592!
242	auto ditype = llvm::dyn_cast<llvm::DIDerivedType>(type);	308✔
243	type = ditype->getBaseType();	308✔
244	}	308✔
245	return type;	568✔
246	};	284✔
247
248	auto* maybe_composite = find_composite(root);	284✔
249	if (!maybe_composite \|\| !llvm::isa<llvm::DICompositeType>(maybe_composite)) {	284!
250	LOG_DEBUG("Returning: DIType is not composite required for TBAA descend.")
251	return root;	222✔
252	}
253
254	auto* composite = llvm::dyn_cast<llvm::DICompositeType>(maybe_composite);	62✔
255
256	LOG_DEBUG("Found maybe legible composite node: " << log::ditype_str(composite))
257
258	// Cpp TBAA uses identifier, in C we use the name:
259	const auto struct_name = [](const auto* composite) {	186✔
260	auto name = std::string{composite->getIdentifier()};	62✔
261	if (name.empty()) {	62✔
262	name = std::string{composite->getName()};	24✔
263	}	24✔
264	return name;	62✔
265	}(composite);	124✔
266
267	if (struct_name != tbaa.base_name() && !tbaa.base_name().empty()) {	62✔
268	LOG_DEBUG("Names differ. Name of struct: \"" << struct_name << "\" vs name of TBAA \"" << tbaa.base_name() << "\".")
269	auto result_composite = helper::find_composite_with_name(tbaa.base_name(), composite);	18✔
270
271	if (result_composite) {	18✔
272	LOG_DEBUG("Found matching sub member " << log::ditype_str(result_composite.value()))
273	composite = result_composite.value(); // const_cast<llvm::DICompositeType*>(result_composite.value());	6✔
274	const auto num_members = di::util::get_num_composite_members(*composite);	6✔
275	const auto num_tbaa = helper::tbaa_operand_count(tbaa.base_ty);	6✔
276	if (num_members != num_tbaa) {	6!
277	LOG_DEBUG("Mismatch between sub member element count and TBAA base type count "
278	<< log::ditype_str(tbaa.base_ty))
279	return root;	×
280	}
281	} else {	6!
282	LOG_DEBUG("Did not find matching sub member: " << struct_name)
283	const auto [new_base, calculated_offset] = helper::tbaa_sub_node_matches_name(struct_name, tbaa.base_ty);	12✔
284	if (!new_base) {	12!
285	LOG_DEBUG("Did not find new base, returning")
286	return root;	12✔
287	}
288	LOG_DEBUG("New TBAA base " << log::ditype_str(new_base.value()) << " with negative offset " << calculated_offset)
UNCOV 289	tbaa.reset_base(new_base.value());	×
UNCOV 290	tbaa.subtract_offset(calculated_offset);	×
291	}	12!
292	}	18✔
293
294	if (struct_name.empty()) {	50✔
295	LOG_DEBUG("No name match possible")
296	// Here no name matching is possible, is TBAA node referring to current DI type? We need to verify:
297	if (!composite_fits_tbaa(composite, tbaa)) {	12!
298	LOG_DEBUG("TBAA of anonymous struct has different offsets to DIComposite type!")
299	return root;	12✔
300	}
UNCOV 301	}	×
302
303	assert(tbaa.access_is_ptr() && "TBAA access should be pointer");	76!
304
305	LOG_DEBUG("TBAA tree data.")
306	LOG_DEBUG(" From ditype: " << log::ditype_str(composite))
307	LOG_DEBUG(" From TBAA: " << log::ditype_str(tbaa.base_ty))
308	LOG_DEBUG(" At offset: " << tbaa.offset_value)
309
310	auto result = di::util::resolve_byte_offset_to_member_of(composite, tbaa.offset_value);	38✔
311	if (result) {	38✔
312	return result->type_of_member;	20✔
313	}
314	return {};	18✔
315	}	284✔
316
317	std::optional<llvm::DIType> resolve_tbaa(llvm::DIType root, const llvm::Instruction& instruction) {	726✔
318	LOG_DEBUG("Resolve TBAA of instruction '" << instruction << "' with ditype: " << log::ditype_str(root))
319
320	auto tbaa = TBAAHandle::create(instruction);	726✔
321	if (!tbaa) {	726✔
322	LOG_DEBUG("Requires TBAA metadata in LLVM IR.")
323	return root;	10✔
324	}
325
326	// assign any ptr to any ptr, e.g., struct A** a; a[0] = malloc(struct A):
327	if (tbaa->base_ty == tbaa->access_ty && tbaa->access_is_ptr()) {	716!
328	LOG_DEBUG("No work: TBAA base type is same as access type (both ptr).")
329	return root;	432✔
330	}
331
332	const auto node = tbaa_resolver(root, tbaa.value());	284✔
333	if (node.has_value() && node.value() != root) {	284✔
334	LOG_DEBUG("Determined new type with TBAA")
335	}	20✔
336
337	return node;	284✔
338	}	726✔
339
340	} // namespace dimeta::tbaa

ahueck / llvm-dimeta / 17187640060

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous