25177145272

Committed 30 Apr 2026 04:30PM UTC coverage: 84.647% (-5.6%) from 90.246%

Build # 25177145272

Build Type

Pull #188

github

Committed by

web-flow

Commit Message

Merge 88918912c into 278119205

Pull Request Pull Request #188: GPU memory allocation support

Coverage Stats

127 of 259 new or added lines in 19 files covered. (49.03%)

200 existing lines in 18 files now uncovered.

4510 of 5328 relevant lines covered (84.65%)

27776.73 hits per line

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

0.0

/lib/passes/support/TypeUtil.cpp

// TypeART library
//
// Copyright (c) 2017-2026 TypeART Authors
// Distributed under the BSD 3-Clause license.
// (See accompanying file LICENSE.txt or copy at
// https://opensource.org/licenses/BSD-3-Clause)
//
// Project home: https://github.com/tudasc/TypeART
//
// SPDX-License-Identifier: BSD-3-Clause
//

#include "TypeUtil.h"

#include "support/Logger.h"

#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/TypeSize.h"
#include "llvm/Support/raw_ostream.h"

#include <optional>

using namespace llvm;

namespace typeart::util::type {

#if LLVM_VERSION_MAJOR < 15
bool isi64Ptr(llvm::Type* type) {
  return type->isPointerTy() && type->getPointerElementType()->isIntegerTy(64);
}

bool isVoidPtr(llvm::Type* type) {
  return type->isPointerTy() && type->getPointerElementType()->isIntegerTy(8);
}
#endif

/**
 * Code was imported from jplehr/llvm-memprofiler project
 */
unsigned getTypeSizeInBytes(llvm::Type* t, const llvm::DataLayout& dl) {
  unsigned bytes = getScalarSizeInBytes(t);

  if (t->isArrayTy()) {
    bytes = getArraySizeInBytes(t, dl);
  } else if (t->isStructTy()) {
    bytes = getStructSizeInBytes(t, dl);
  } else if (t->isPointerTy()) {
    bytes = getPointerSizeInBytes(t, dl);
  } else if (t->isVectorTy()) {
    bytes = getVectorSizeInBytes(t, dl);
  }

  return bytes;
}

unsigned getScalarSizeInBytes(llvm::Type* t) {
  return t->getScalarSizeInBits() / 8;
}

unsigned getArraySizeInBytes(llvm::Type* arrT, const llvm::DataLayout& dl) {
  auto st = dyn_cast<ArrayType>(arrT);
  return getTypeSizeInBytes(getArrayElementType(st), dl) * getArrayLengthFlattened(st);
}

unsigned getVectorSizeInBytes(llvm::Type* vectorT, const llvm::DataLayout& dl) {
  // TODO: Most of these utility functions can be eliminated with the use of getTypeAllocSize() and getTypeStoreSize()
  //  auto vt = dyn_cast<VectorType>(vectorT);
  return dl.getTypeAllocSize(vectorT);
  // return getTypeSizeInBytes(vt->getVectorElementType(), dl) * vt->getVectorNumElements();
}

/**
 * \brief Resolves the element type of the given array recursively. Works for multidimensional arrays.
 */
llvm::Type* getArrayElementType(llvm::Type* arrT) {
  while (arrT->isArrayTy()) {
    arrT = arrT->getArrayElementType();
  }
  return arrT;
}

/**
 * \brief Determines the length of the flattened array.
 *  TODO: Handle VLAs
 */
unsigned getArrayLengthFlattened(llvm::Type* arrT) {
  unsigned len = 1;
  while (arrT->isArrayTy()) {
    len *= arrT->getArrayNumElements();
    arrT = arrT->getArrayElementType();
  }
  return len;
}

unsigned getStructSizeInBytes(llvm::Type* structT, const llvm::DataLayout& dl) {
  auto st                    = dyn_cast<llvm::StructType>(structT);
  const StructLayout* layout = dl.getStructLayout(st);
  return layout->getSizeInBytes();
}

unsigned getPointerSizeInBytes(llvm::Type* /*ptrT*/, const llvm::DataLayout& dl) {
  return dl.getPointerSizeInBits() / 8;
}

std::optional<llvm::Type*> getPointerElementType(llvm::Type* ptr_type) {
  auto* pointer_type = dyn_cast_or_null<llvm::PointerType>(ptr_type);
  if (pointer_type == nullptr) {
    return {};
  }

#if LLVM_VERSION_MAJOR < 15
  return pointer_type->getPointerElementType();
#else
  return {};
#endif
}

}  // namespace typeart::util::type

1	// TypeART library
2	//
3	// Copyright (c) 2017-2026 TypeART Authors
4	// Distributed under the BSD 3-Clause license.
5	// (See accompanying file LICENSE.txt or copy at
6	// https://opensource.org/licenses/BSD-3-Clause)
7	//
8	// Project home: https://github.com/tudasc/TypeART
9	//
10	// SPDX-License-Identifier: BSD-3-Clause
11	//
12
13	#include "TypeUtil.h"
14
15	#include "support/Logger.h"
16
17	#include "llvm/IR/Constants.h"
18	#include "llvm/IR/DataLayout.h"
19	#include "llvm/IR/DerivedTypes.h"
20	#include "llvm/IR/Instructions.h"
21	#include "llvm/IR/Type.h"
22	#include "llvm/IR/Value.h"
23	#include "llvm/Support/Casting.h"
24	#include "llvm/Support/TypeSize.h"
25	#include "llvm/Support/raw_ostream.h"
26
27	#include <optional>
28
29	using namespace llvm;
30
31	namespace typeart::util::type {
32
33	#if LLVM_VERSION_MAJOR < 15
34	bool isi64Ptr(llvm::Type* type) {
35	return type->isPointerTy() && type->getPointerElementType()->isIntegerTy(64);
36	}
37
38	bool isVoidPtr(llvm::Type* type) {
39	return type->isPointerTy() && type->getPointerElementType()->isIntegerTy(8);
40	}
41	#endif
42
43	/**
44	* Code was imported from jplehr/llvm-memprofiler project
45	*/
UNCOV 46	unsigned getTypeSizeInBytes(llvm::Type* t, const llvm::DataLayout& dl) {	×
UNCOV 47	unsigned bytes = getScalarSizeInBytes(t);	×
48
UNCOV 49	if (t->isArrayTy()) {	×
UNCOV 50	bytes = getArraySizeInBytes(t, dl);	×
UNCOV 51	} else if (t->isStructTy()) {	×
UNCOV 52	bytes = getStructSizeInBytes(t, dl);	×
UNCOV 53	} else if (t->isPointerTy()) {	×
UNCOV 54	bytes = getPointerSizeInBytes(t, dl);	×
UNCOV 55	} else if (t->isVectorTy()) {	×
UNCOV 56	bytes = getVectorSizeInBytes(t, dl);	×
UNCOV 57	}	×
58
UNCOV 59	return bytes;	×
60	}
61
UNCOV 62	unsigned getScalarSizeInBytes(llvm::Type* t) {	×
UNCOV 63	return t->getScalarSizeInBits() / 8;	×
64	}
65
UNCOV 66	unsigned getArraySizeInBytes(llvm::Type* arrT, const llvm::DataLayout& dl) {	×
UNCOV 67	auto st = dyn_cast<ArrayType>(arrT);	×
UNCOV 68	return getTypeSizeInBytes(getArrayElementType(st), dl) * getArrayLengthFlattened(st);	×
69	}
70
UNCOV 71	unsigned getVectorSizeInBytes(llvm::Type* vectorT, const llvm::DataLayout& dl) {	×
72	// TODO: Most of these utility functions can be eliminated with the use of getTypeAllocSize() and getTypeStoreSize()
73	// auto vt = dyn_cast<VectorType>(vectorT);
UNCOV 74	return dl.getTypeAllocSize(vectorT);	×
75	// return getTypeSizeInBytes(vt->getVectorElementType(), dl) * vt->getVectorNumElements();
76	}
77
78	/**
79	* \brief Resolves the element type of the given array recursively. Works for multidimensional arrays.
80	*/
UNCOV 81	llvm::Type* getArrayElementType(llvm::Type* arrT) {	×
UNCOV 82	while (arrT->isArrayTy()) {	×
UNCOV 83	arrT = arrT->getArrayElementType();	×
84	}
UNCOV 85	return arrT;	×
86	}
87
88	/**
89	* \brief Determines the length of the flattened array.
90	* TODO: Handle VLAs
91	*/
UNCOV 92	unsigned getArrayLengthFlattened(llvm::Type* arrT) {	×
UNCOV 93	unsigned len = 1;	×
UNCOV 94	while (arrT->isArrayTy()) {	×
UNCOV 95	len *= arrT->getArrayNumElements();	×
UNCOV 96	arrT = arrT->getArrayElementType();	×
97	}
UNCOV 98	return len;	×
99	}
100
UNCOV 101	unsigned getStructSizeInBytes(llvm::Type* structT, const llvm::DataLayout& dl) {	×
UNCOV 102	auto st = dyn_cast<llvm::StructType>(structT);	×
UNCOV 103	const StructLayout* layout = dl.getStructLayout(st);	×
UNCOV 104	return layout->getSizeInBytes();	×
105	}
106
UNCOV 107	unsigned getPointerSizeInBytes(llvm::Type* /ptrT/, const llvm::DataLayout& dl) {	×
UNCOV 108	return dl.getPointerSizeInBits() / 8;	×
109	}
110
NEW 111	std::optional<llvm::Type> getPointerElementType(llvm::Type ptr_type) {	×
NEW 112	auto* pointer_type = dyn_cast_or_null<llvm::PointerType>(ptr_type);	×
NEW 113	if (pointer_type == nullptr) {	×
NEW 114	return {};	×
115	}
116
117	#if LLVM_VERSION_MAJOR < 15
118	return pointer_type->getPointerElementType();
119	#else
NEW 120	return {};	×
121	#endif
NEW 122	}	×
123
124	} // namespace typeart::util::type

tudasc / TypeART / 25177145272

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