//===- BuiltinAttributes.cpp - MLIR Builtin Attribute Classes -------------===// // // 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 "mlir/IR/BuiltinAttributes.h" #include "AttributeDetail.h" #include "mlir/IR/AffineMap.h" #include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/Dialect.h" #include "mlir/IR/DialectResourceBlobManager.h" #include "mlir/IR/IntegerSet.h" #include "mlir/IR/OpImplementation.h" #include "mlir/IR/Operation.h" #include "mlir/IR/SymbolTable.h" #include "mlir/IR/Types.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/TypeSwitch.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Endian.h" #include <optional> #define DEBUG_TYPE … usingnamespacemlir; usingnamespacemlir::detail; //===----------------------------------------------------------------------===// /// Tablegen Attribute Definitions //===----------------------------------------------------------------------===// #define GET_ATTRDEF_CLASSES #include "mlir/IR/BuiltinAttributes.cpp.inc" //===----------------------------------------------------------------------===// // BuiltinDialect //===----------------------------------------------------------------------===// void BuiltinDialect::registerAttributes() { … } //===----------------------------------------------------------------------===// // DictionaryAttr //===----------------------------------------------------------------------===// /// Helper function that does either an in place sort or sorts from source array /// into destination. If inPlace then storage is both the source and the /// destination, else value is the source and storage destination. Returns /// whether source was sorted. template <bool inPlace> static bool dictionaryAttrSort(ArrayRef<NamedAttribute> value, SmallVectorImpl<NamedAttribute> &storage) { … } /// Returns an entry with a duplicate name from the given sorted array of named /// attributes. Returns std::nullopt if all elements have unique names. static std::optional<NamedAttribute> findDuplicateElement(ArrayRef<NamedAttribute> value) { … } bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value, SmallVectorImpl<NamedAttribute> &storage) { … } bool DictionaryAttr::sortInPlace(SmallVectorImpl<NamedAttribute> &array) { … } std::optional<NamedAttribute> DictionaryAttr::findDuplicate(SmallVectorImpl<NamedAttribute> &array, bool isSorted) { … } DictionaryAttr DictionaryAttr::get(MLIRContext *context, ArrayRef<NamedAttribute> value) { … } /// Construct a dictionary with an array of values that is known to already be /// sorted by name and uniqued. DictionaryAttr DictionaryAttr::getWithSorted(MLIRContext *context, ArrayRef<NamedAttribute> value) { … } /// Return the specified attribute if present, null otherwise. Attribute DictionaryAttr::get(StringRef name) const { … } Attribute DictionaryAttr::get(StringAttr name) const { … } /// Return the specified named attribute if present, std::nullopt otherwise. std::optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name) const { … } std::optional<NamedAttribute> DictionaryAttr::getNamed(StringAttr name) const { … } /// Return whether the specified attribute is present. bool DictionaryAttr::contains(StringRef name) const { … } bool DictionaryAttr::contains(StringAttr name) const { … } DictionaryAttr::iterator DictionaryAttr::begin() const { … } DictionaryAttr::iterator DictionaryAttr::end() const { … } size_t DictionaryAttr::size() const { … } DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) { … } //===----------------------------------------------------------------------===// // StridedLayoutAttr //===----------------------------------------------------------------------===// /// Prints a strided layout attribute. void StridedLayoutAttr::print(llvm::raw_ostream &os) const { … } /// Returns true if this layout is static, i.e. the strides and offset all have /// a known value > 0. bool StridedLayoutAttr::hasStaticLayout() const { … } /// Returns the strided layout as an affine map. AffineMap StridedLayoutAttr::getAffineMap() const { … } /// Checks that the type-agnostic strided layout invariants are satisfied. LogicalResult StridedLayoutAttr::verify(function_ref<InFlightDiagnostic()> emitError, int64_t offset, ArrayRef<int64_t> strides) { … } /// Checks that the type-specific strided layout invariants are satisfied. LogicalResult StridedLayoutAttr::verifyLayout( ArrayRef<int64_t> shape, function_ref<InFlightDiagnostic()> emitError) const { … } //===----------------------------------------------------------------------===// // StringAttr //===----------------------------------------------------------------------===// StringAttr StringAttr::getEmptyStringAttrUnchecked(MLIRContext *context) { … } /// Twine support for StringAttr. StringAttr StringAttr::get(MLIRContext *context, const Twine &twine) { … } /// Twine support for StringAttr. StringAttr StringAttr::get(const Twine &twine, Type type) { … } StringRef StringAttr::getValue() const { … } Type StringAttr::getType() const { … } Dialect *StringAttr::getReferencedDialect() const { … } //===----------------------------------------------------------------------===// // FloatAttr //===----------------------------------------------------------------------===// double FloatAttr::getValueAsDouble() const { … } double FloatAttr::getValueAsDouble(APFloat value) { … } LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError, Type type, APFloat value) { … } //===----------------------------------------------------------------------===// // SymbolRefAttr //===----------------------------------------------------------------------===// SymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value, ArrayRef<FlatSymbolRefAttr> nestedRefs) { … } FlatSymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value) { … } FlatSymbolRefAttr SymbolRefAttr::get(StringAttr value) { … } FlatSymbolRefAttr SymbolRefAttr::get(Operation *symbol) { … } StringAttr SymbolRefAttr::getLeafReference() const { … } //===----------------------------------------------------------------------===// // IntegerAttr //===----------------------------------------------------------------------===// int64_t IntegerAttr::getInt() const { … } int64_t IntegerAttr::getSInt() const { … } uint64_t IntegerAttr::getUInt() const { … } /// Return the value as an APSInt which carries the signed from the type of /// the attribute. This traps on signless integers types! APSInt IntegerAttr::getAPSInt() const { … } LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError, Type type, APInt value) { … } BoolAttr IntegerAttr::getBoolAttrUnchecked(IntegerType type, bool value) { … } //===----------------------------------------------------------------------===// // BoolAttr //===----------------------------------------------------------------------===// bool BoolAttr::getValue() const { … } bool BoolAttr::classof(Attribute attr) { … } //===----------------------------------------------------------------------===// // OpaqueAttr //===----------------------------------------------------------------------===// LogicalResult OpaqueAttr::verify(function_ref<InFlightDiagnostic()> emitError, StringAttr dialect, StringRef attrData, Type type) { … } //===----------------------------------------------------------------------===// // DenseElementsAttr Utilities //===----------------------------------------------------------------------===// const char DenseIntOrFPElementsAttrStorage::kSplatTrue = …; const char DenseIntOrFPElementsAttrStorage::kSplatFalse = …; /// Get the bitwidth of a dense element type within the buffer. /// DenseElementsAttr requires bitwidths greater than 1 to be aligned by 8. static size_t getDenseElementStorageWidth(size_t origWidth) { … } static size_t getDenseElementStorageWidth(Type elementType) { … } /// Set a bit to a specific value. static void setBit(char *rawData, size_t bitPos, bool value) { … } /// Return the value of the specified bit. static bool getBit(const char *rawData, size_t bitPos) { … } /// Copy actual `numBytes` data from `value` (APInt) to char array(`result`) for /// BE format. static void copyAPIntToArrayForBEmachine(APInt value, size_t numBytes, char *result) { … } /// Copy `numBytes` data from `inArray`(char array) to `result`(APINT) for BE /// format. static void copyArrayToAPIntForBEmachine(const char *inArray, size_t numBytes, APInt &result) { … } /// Writes value to the bit position `bitPos` in array `rawData`. static void writeBits(char *rawData, size_t bitPos, APInt value) { … } /// Reads the next `bitWidth` bits from the bit position `bitPos` in array /// `rawData`. static APInt readBits(const char *rawData, size_t bitPos, size_t bitWidth) { … } /// Returns true if 'values' corresponds to a splat, i.e. one element, or has /// the same element count as 'type'. template <typename Values> static bool hasSameElementsOrSplat(ShapedType type, const Values &values) { … } //===----------------------------------------------------------------------===// // DenseElementsAttr Iterators //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// // AttributeElementIterator DenseElementsAttr::AttributeElementIterator::AttributeElementIterator( DenseElementsAttr attr, size_t index) : … { … } Attribute DenseElementsAttr::AttributeElementIterator::operator*() const { … } //===----------------------------------------------------------------------===// // BoolElementIterator DenseElementsAttr::BoolElementIterator::BoolElementIterator( DenseElementsAttr attr, size_t dataIndex) : … { … } bool DenseElementsAttr::BoolElementIterator::operator*() const { … } //===----------------------------------------------------------------------===// // IntElementIterator DenseElementsAttr::IntElementIterator::IntElementIterator( DenseElementsAttr attr, size_t dataIndex) : … { … } APInt DenseElementsAttr::IntElementIterator::operator*() const { … } //===----------------------------------------------------------------------===// // ComplexIntElementIterator DenseElementsAttr::ComplexIntElementIterator::ComplexIntElementIterator( DenseElementsAttr attr, size_t dataIndex) : … { … } std::complex<APInt> DenseElementsAttr::ComplexIntElementIterator::operator*() const { … } //===----------------------------------------------------------------------===// // DenseArrayAttr //===----------------------------------------------------------------------===// LogicalResult DenseArrayAttr::verify(function_ref<InFlightDiagnostic()> emitError, Type elementType, int64_t size, ArrayRef<char> rawData) { … } namespace { /// Instantiations of this class provide utilities for interacting with native /// data types in the context of DenseArrayAttr. template <size_t width, IntegerType::SignednessSemantics signedness = IntegerType::Signless> struct DenseArrayAttrIntUtil { … }; template <typename T> struct DenseArrayAttrUtil; /// Specialization for boolean elements to print 'true' and 'false' literals for /// elements. template <> struct DenseArrayAttrUtil<bool> : public DenseArrayAttrIntUtil<1> { … }; /// Specialization for 8-bit integers to ensure values are printed as integers /// and not characters. template <> struct DenseArrayAttrUtil<int8_t> : public DenseArrayAttrIntUtil<8> { … }; template <> struct DenseArrayAttrUtil<int16_t> : public DenseArrayAttrIntUtil<16> { … }; template <> struct DenseArrayAttrUtil<int32_t> : public DenseArrayAttrIntUtil<32> { … }; template <> struct DenseArrayAttrUtil<int64_t> : public DenseArrayAttrIntUtil<64> { … }; /// Specialization for 32-bit floats. template <> struct DenseArrayAttrUtil<float> { … }; /// Specialization for 64-bit floats. template <> struct DenseArrayAttrUtil<double> { … }; } // namespace template <typename T> void DenseArrayAttrImpl<T>::print(AsmPrinter &printer) const { … } template <typename T> void DenseArrayAttrImpl<T>::printWithoutBraces(raw_ostream &os) const { … } template <typename T> void DenseArrayAttrImpl<T>::print(raw_ostream &os) const { … } /// Parse a DenseArrayAttr without the braces: `1, 2, 3` template <typename T> Attribute DenseArrayAttrImpl<T>::parseWithoutBraces(AsmParser &parser, Type odsType) { … } /// Parse a DenseArrayAttr: `[ 1, 2, 3 ]` template <typename T> Attribute DenseArrayAttrImpl<T>::parse(AsmParser &parser, Type odsType) { … } /// Conversion from DenseArrayAttr<T> to ArrayRef<T>. operator ArrayRef<type-parameter-0-0>() /// Builds a DenseArrayAttr<T> from an ArrayRef<T>. template <typename T> DenseArrayAttrImpl<T> DenseArrayAttrImpl<T>::get(MLIRContext *context, ArrayRef<T> content) { … } template <typename T> bool DenseArrayAttrImpl<T>::classof(Attribute attr) { … } namespace mlir { namespace detail { // Explicit instantiation for all the supported DenseArrayAttr. template class DenseArrayAttrImpl<bool>; template class DenseArrayAttrImpl<int8_t>; template class DenseArrayAttrImpl<int16_t>; template class DenseArrayAttrImpl<int32_t>; template class DenseArrayAttrImpl<int64_t>; template class DenseArrayAttrImpl<float>; template class DenseArrayAttrImpl<double>; } // namespace detail } // namespace mlir //===----------------------------------------------------------------------===// // DenseElementsAttr //===----------------------------------------------------------------------===// /// Method for support type inquiry through isa, cast and dyn_cast. bool DenseElementsAttr::classof(Attribute attr) { … } DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<Attribute> values) { … } DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<bool> values) { … } DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<StringRef> values) { … } /// Constructs a dense integer elements attribute from an array of APInt /// values. Each APInt value is expected to have the same bitwidth as the /// element type of 'type'. DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<APInt> values) { … } DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<std::complex<APInt>> values) { … } // Constructs a dense float elements attribute from an array of APFloat // values. Each APFloat value is expected to have the same bitwidth as the // element type of 'type'. DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<APFloat> values) { … } DenseElementsAttr DenseElementsAttr::get(ShapedType type, ArrayRef<std::complex<APFloat>> values) { … } /// Construct a dense elements attribute from a raw buffer representing the /// data for this attribute. Users should generally not use this methods as /// the expected buffer format may not be a form the user expects. DenseElementsAttr DenseElementsAttr::getFromRawBuffer(ShapedType type, ArrayRef<char> rawBuffer) { … } /// Returns true if the given buffer is a valid raw buffer for the given type. bool DenseElementsAttr::isValidRawBuffer(ShapedType type, ArrayRef<char> rawBuffer, bool &detectedSplat) { … } /// Check the information for a C++ data type, check if this type is valid for /// the current attribute. This method is used to verify specific type /// invariants that the templatized 'getValues' method cannot. static bool isValidIntOrFloat(Type type, int64_t dataEltSize, bool isInt, bool isSigned) { … } /// Defaults down the subclass implementation. DenseElementsAttr DenseElementsAttr::getRawComplex(ShapedType type, ArrayRef<char> data, int64_t dataEltSize, bool isInt, bool isSigned) { … } DenseElementsAttr DenseElementsAttr::getRawIntOrFloat(ShapedType type, ArrayRef<char> data, int64_t dataEltSize, bool isInt, bool isSigned) { … } bool DenseElementsAttr::isValidIntOrFloat(int64_t dataEltSize, bool isInt, bool isSigned) const { … } bool DenseElementsAttr::isValidComplex(int64_t dataEltSize, bool isInt, bool isSigned) const { … } /// Returns true if this attribute corresponds to a splat, i.e. if all element /// values are the same. bool DenseElementsAttr::isSplat() const { … } /// Return if the given complex type has an integer element type. static bool isComplexOfIntType(Type type) { … } auto DenseElementsAttr::tryGetComplexIntValues() const -> FailureOr<iterator_range_impl<ComplexIntElementIterator>> { … } auto DenseElementsAttr::tryGetFloatValues() const -> FailureOr<iterator_range_impl<FloatElementIterator>> { … } auto DenseElementsAttr::tryGetComplexFloatValues() const -> FailureOr<iterator_range_impl<ComplexFloatElementIterator>> { … } /// Return the raw storage data held by this attribute. ArrayRef<char> DenseElementsAttr::getRawData() const { … } ArrayRef<StringRef> DenseElementsAttr::getRawStringData() const { … } /// Return a new DenseElementsAttr that has the same data as the current /// attribute, but has been reshaped to 'newType'. The new type must have the /// same total number of elements as well as element type. DenseElementsAttr DenseElementsAttr::reshape(ShapedType newType) { … } DenseElementsAttr DenseElementsAttr::resizeSplat(ShapedType newType) { … } /// Return a new DenseElementsAttr that has the same data as the current /// attribute, but has bitcast elements such that it is now 'newType'. The new /// type must have the same shape and element types of the same bitwidth as the /// current type. DenseElementsAttr DenseElementsAttr::bitcast(Type newElType) { … } DenseElementsAttr DenseElementsAttr::mapValues(Type newElementType, function_ref<APInt(const APInt &)> mapping) const { … } DenseElementsAttr DenseElementsAttr::mapValues( Type newElementType, function_ref<APInt(const APFloat &)> mapping) const { … } ShapedType DenseElementsAttr::getType() const { … } Type DenseElementsAttr::getElementType() const { … } int64_t DenseElementsAttr::getNumElements() const { … } //===----------------------------------------------------------------------===// // DenseIntOrFPElementsAttr //===----------------------------------------------------------------------===// /// Utility method to write a range of APInt values to a buffer. template <typename APRangeT> static void writeAPIntsToBuffer(size_t storageWidth, std::vector<char> &data, APRangeT &&values) { … } /// Constructs a dense elements attribute from an array of raw APFloat values. /// Each APFloat value is expected to have the same bitwidth as the element /// type of 'type'. 'type' must be a vector or tensor with static shape. DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type, size_t storageWidth, ArrayRef<APFloat> values) { … } /// Constructs a dense elements attribute from an array of raw APInt values. /// Each APInt value is expected to have the same bitwidth as the element type /// of 'type'. DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type, size_t storageWidth, ArrayRef<APInt> values) { … } DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type, ArrayRef<char> data) { … } /// Overload of the raw 'get' method that asserts that the given type is of /// complex type. This method is used to verify type invariants that the /// templatized 'get' method cannot. DenseElementsAttr DenseIntOrFPElementsAttr::getRawComplex(ShapedType type, ArrayRef<char> data, int64_t dataEltSize, bool isInt, bool isSigned) { … } /// Overload of the 'getRaw' method that asserts that the given type is of /// integer type. This method is used to verify type invariants that the /// templatized 'get' method cannot. DenseElementsAttr DenseIntOrFPElementsAttr::getRawIntOrFloat(ShapedType type, ArrayRef<char> data, int64_t dataEltSize, bool isInt, bool isSigned) { … } void DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine( const char *inRawData, char *outRawData, size_t elementBitWidth, size_t numElements) { … } void DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine( ArrayRef<char> inRawData, MutableArrayRef<char> outRawData, ShapedType type) { … } //===----------------------------------------------------------------------===// // DenseFPElementsAttr //===----------------------------------------------------------------------===// template <typename Fn, typename Attr> static ShapedType mappingHelper(Fn mapping, Attr &attr, ShapedType inType, Type newElementType, llvm::SmallVectorImpl<char> &data) { … } DenseElementsAttr DenseFPElementsAttr::mapValues( Type newElementType, function_ref<APInt(const APFloat &)> mapping) const { … } /// Method for supporting type inquiry through isa, cast and dyn_cast. bool DenseFPElementsAttr::classof(Attribute attr) { … } //===----------------------------------------------------------------------===// // DenseIntElementsAttr //===----------------------------------------------------------------------===// DenseElementsAttr DenseIntElementsAttr::mapValues( Type newElementType, function_ref<APInt(const APInt &)> mapping) const { … } /// Method for supporting type inquiry through isa, cast and dyn_cast. bool DenseIntElementsAttr::classof(Attribute attr) { … } //===----------------------------------------------------------------------===// // DenseResourceElementsAttr //===----------------------------------------------------------------------===// DenseResourceElementsAttr DenseResourceElementsAttr::get(ShapedType type, DenseResourceElementsHandle handle) { … } DenseResourceElementsAttr DenseResourceElementsAttr::get(ShapedType type, StringRef blobName, AsmResourceBlob blob) { … } //===----------------------------------------------------------------------===// // DenseResourceElementsAttrBase namespace { /// Instantiations of this class provide utilities for interacting with native /// data types in the context of DenseResourceElementsAttr. template <typename T> struct DenseResourceAttrUtil; template <size_t width, bool isSigned> struct DenseResourceElementsAttrIntUtil { … }; template <> struct DenseResourceAttrUtil<bool> { … }; template <> struct DenseResourceAttrUtil<int8_t> : public DenseResourceElementsAttrIntUtil<8, true> { … }; template <> struct DenseResourceAttrUtil<uint8_t> : public DenseResourceElementsAttrIntUtil<8, false> { … }; template <> struct DenseResourceAttrUtil<int16_t> : public DenseResourceElementsAttrIntUtil<16, true> { … }; template <> struct DenseResourceAttrUtil<uint16_t> : public DenseResourceElementsAttrIntUtil<16, false> { … }; template <> struct DenseResourceAttrUtil<int32_t> : public DenseResourceElementsAttrIntUtil<32, true> { … }; template <> struct DenseResourceAttrUtil<uint32_t> : public DenseResourceElementsAttrIntUtil<32, false> { … }; template <> struct DenseResourceAttrUtil<int64_t> : public DenseResourceElementsAttrIntUtil<64, true> { … }; template <> struct DenseResourceAttrUtil<uint64_t> : public DenseResourceElementsAttrIntUtil<64, false> { … }; template <> struct DenseResourceAttrUtil<float> { … }; template <> struct DenseResourceAttrUtil<double> { … }; } // namespace template <typename T> DenseResourceElementsAttrBase<T> DenseResourceElementsAttrBase<T>::get(ShapedType type, StringRef blobName, AsmResourceBlob blob) { … } template <typename T> std::optional<ArrayRef<T>> DenseResourceElementsAttrBase<T>::tryGetAsArrayRef() const { … } template <typename T> bool DenseResourceElementsAttrBase<T>::classof(Attribute attr) { … } namespace mlir { namespace detail { // Explicit instantiation for all the supported DenseResourceElementsAttr. template class DenseResourceElementsAttrBase<bool>; template class DenseResourceElementsAttrBase<int8_t>; template class DenseResourceElementsAttrBase<int16_t>; template class DenseResourceElementsAttrBase<int32_t>; template class DenseResourceElementsAttrBase<int64_t>; template class DenseResourceElementsAttrBase<uint8_t>; template class DenseResourceElementsAttrBase<uint16_t>; template class DenseResourceElementsAttrBase<uint32_t>; template class DenseResourceElementsAttrBase<uint64_t>; template class DenseResourceElementsAttrBase<float>; template class DenseResourceElementsAttrBase<double>; } // namespace detail } // namespace mlir //===----------------------------------------------------------------------===// // SparseElementsAttr //===----------------------------------------------------------------------===// /// Get a zero APFloat for the given sparse attribute. APFloat SparseElementsAttr::getZeroAPFloat() const { … } /// Get a zero APInt for the given sparse attribute. APInt SparseElementsAttr::getZeroAPInt() const { … } /// Get a zero attribute for the given attribute type. Attribute SparseElementsAttr::getZeroAttr() const { … } /// Flatten, and return, all of the sparse indices in this attribute in /// row-major order. std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices() const { … } LogicalResult SparseElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError, ShapedType type, DenseIntElementsAttr sparseIndices, DenseElementsAttr values) { … } //===----------------------------------------------------------------------===// // DistinctAttr //===----------------------------------------------------------------------===// DistinctAttr DistinctAttr::create(Attribute referencedAttr) { … } Attribute DistinctAttr::getReferencedAttr() const { … } //===----------------------------------------------------------------------===// // Attribute Utilities //===----------------------------------------------------------------------===// AffineMap mlir::makeStridedLinearLayoutMap(ArrayRef<int64_t> strides, int64_t offset, MLIRContext *context) { … }
Codebase Browser
llvm