2017-05-06 06:30:37 +08:00
|
|
|
//===- DataLayout.cpp - Data size & alignment routines ---------------------==//
|
2012-10-05 06:08:14 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2012-10-05 06:08:14 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2012-10-05 07:01:22 +08:00
|
|
|
// This file defines layout properties related to datatype size/offset/alignment
|
2012-10-05 06:08:14 +08:00
|
|
|
// information.
|
|
|
|
//
|
|
|
|
// This structure should be created once, filled in if the defaults are not
|
|
|
|
// correct and then passed around by const&. None of the members functions
|
|
|
|
// require modification to the object.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2017-05-06 06:30:37 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2014-01-04 03:21:54 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-03-04 18:40:04 +08:00
|
|
|
#include "llvm/IR/GetElementPtrTypeIterator.h"
|
2017-05-06 06:30:37 +08:00
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2017-05-06 06:30:37 +08:00
|
|
|
#include "llvm/IR/Type.h"
|
|
|
|
#include "llvm/IR/Value.h"
|
|
|
|
#include "llvm/Support/Casting.h"
|
2020-08-17 19:34:07 +08:00
|
|
|
#include "llvm/Support/Error.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/MathExtras.h"
|
2019-10-08 20:53:54 +08:00
|
|
|
#include "llvm/Support/TypeSize.h"
|
2012-10-05 06:08:14 +08:00
|
|
|
#include <algorithm>
|
2017-05-06 06:30:37 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <cstdint>
|
2012-10-05 06:08:14 +08:00
|
|
|
#include <cstdlib>
|
2017-05-06 06:30:37 +08:00
|
|
|
#include <tuple>
|
|
|
|
#include <utility>
|
|
|
|
|
2012-10-05 06:08:14 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Support for StructLayout
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-07-28 01:15:28 +08:00
|
|
|
StructLayout::StructLayout(StructType *ST, const DataLayout &DL) {
|
2012-10-05 06:08:14 +08:00
|
|
|
assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
|
|
|
|
StructSize = 0;
|
2015-12-15 09:44:07 +08:00
|
|
|
IsPadded = false;
|
2012-10-05 06:08:14 +08:00
|
|
|
NumElements = ST->getNumElements();
|
|
|
|
|
|
|
|
// Loop over each of the elements, placing them in memory.
|
|
|
|
for (unsigned i = 0, e = NumElements; i != e; ++i) {
|
|
|
|
Type *Ty = ST->getElementType(i);
|
2020-07-01 22:31:56 +08:00
|
|
|
const Align TyAlign = ST->isPacked() ? Align(1) : DL.getABITypeAlign(Ty);
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Add padding if necessary to align the data element properly.
|
2019-09-20 21:40:31 +08:00
|
|
|
if (!isAligned(TyAlign, StructSize)) {
|
2015-12-15 09:44:07 +08:00
|
|
|
IsPadded = true;
|
2016-01-15 05:06:47 +08:00
|
|
|
StructSize = alignTo(StructSize, TyAlign);
|
2015-12-15 09:44:07 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Keep track of maximum alignment constraint.
|
|
|
|
StructAlignment = std::max(TyAlign, StructAlignment);
|
|
|
|
|
2021-03-31 07:43:12 +08:00
|
|
|
getMemberOffsets()[i] = StructSize;
|
2021-01-18 15:29:43 +08:00
|
|
|
// Consume space for this data item
|
|
|
|
StructSize += DL.getTypeAllocSize(Ty).getFixedValue();
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add padding to the end of the struct so that it could be put in an array
|
|
|
|
// and all array elements would be aligned correctly.
|
2019-09-20 21:40:31 +08:00
|
|
|
if (!isAligned(StructAlignment, StructSize)) {
|
2015-12-15 09:44:07 +08:00
|
|
|
IsPadded = true;
|
2016-01-15 05:06:47 +08:00
|
|
|
StructSize = alignTo(StructSize, StructAlignment);
|
2015-12-15 09:44:07 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getElementContainingOffset - Given a valid offset into the structure,
|
|
|
|
/// return the structure index that contains it.
|
|
|
|
unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
|
2021-03-31 07:43:12 +08:00
|
|
|
ArrayRef<uint64_t> MemberOffsets = getMemberOffsets();
|
|
|
|
auto SI = llvm::upper_bound(MemberOffsets, Offset);
|
|
|
|
assert(SI != MemberOffsets.begin() && "Offset not in structure type!");
|
2012-10-05 06:08:14 +08:00
|
|
|
--SI;
|
|
|
|
assert(*SI <= Offset && "upper_bound didn't work");
|
2021-03-31 07:43:12 +08:00
|
|
|
assert((SI == MemberOffsets.begin() || *(SI - 1) <= Offset) &&
|
|
|
|
(SI + 1 == MemberOffsets.end() || *(SI + 1) > Offset) &&
|
2012-10-05 06:08:14 +08:00
|
|
|
"Upper bound didn't work!");
|
|
|
|
|
|
|
|
// Multiple fields can have the same offset if any of them are zero sized.
|
|
|
|
// For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
|
|
|
|
// at the i32 element, because it is the last element at that offset. This is
|
|
|
|
// the right one to return, because anything after it will have a higher
|
|
|
|
// offset, implying that this element is non-empty.
|
2021-03-31 07:43:12 +08:00
|
|
|
return SI - MemberOffsets.begin();
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2012-10-05 07:01:22 +08:00
|
|
|
// LayoutAlignElem, LayoutAlign support
|
2012-10-05 06:08:14 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2019-09-27 20:54:21 +08:00
|
|
|
LayoutAlignElem LayoutAlignElem::get(AlignTypeEnum align_type, Align abi_align,
|
|
|
|
Align pref_align, uint32_t bit_width) {
|
2012-10-05 06:08:14 +08:00
|
|
|
assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
|
2012-10-05 07:01:22 +08:00
|
|
|
LayoutAlignElem retval;
|
2012-10-05 06:08:14 +08:00
|
|
|
retval.AlignType = align_type;
|
|
|
|
retval.ABIAlign = abi_align;
|
|
|
|
retval.PrefAlign = pref_align;
|
|
|
|
retval.TypeBitWidth = bit_width;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2012-10-05 07:01:22 +08:00
|
|
|
LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const {
|
2012-10-05 06:08:14 +08:00
|
|
|
return (AlignType == rhs.AlignType
|
|
|
|
&& ABIAlign == rhs.ABIAlign
|
|
|
|
&& PrefAlign == rhs.PrefAlign
|
|
|
|
&& TypeBitWidth == rhs.TypeBitWidth);
|
|
|
|
}
|
|
|
|
|
2012-10-10 00:06:12 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PointerAlignElem, PointerAlign support
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2019-09-27 20:54:21 +08:00
|
|
|
PointerAlignElem PointerAlignElem::get(uint32_t AddressSpace, Align ABIAlign,
|
|
|
|
Align PrefAlign, uint32_t TypeByteWidth,
|
2019-09-20 21:40:31 +08:00
|
|
|
uint32_t IndexWidth) {
|
2013-12-14 07:15:20 +08:00
|
|
|
assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
|
2012-10-10 00:06:12 +08:00
|
|
|
PointerAlignElem retval;
|
2013-12-14 07:15:20 +08:00
|
|
|
retval.AddressSpace = AddressSpace;
|
|
|
|
retval.ABIAlign = ABIAlign;
|
|
|
|
retval.PrefAlign = PrefAlign;
|
|
|
|
retval.TypeByteWidth = TypeByteWidth;
|
2018-02-14 14:58:08 +08:00
|
|
|
retval.IndexWidth = IndexWidth;
|
2012-10-10 00:06:12 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
PointerAlignElem::operator==(const PointerAlignElem &rhs) const {
|
|
|
|
return (ABIAlign == rhs.ABIAlign
|
|
|
|
&& AddressSpace == rhs.AddressSpace
|
|
|
|
&& PrefAlign == rhs.PrefAlign
|
2018-02-14 14:58:08 +08:00
|
|
|
&& TypeByteWidth == rhs.TypeByteWidth
|
|
|
|
&& IndexWidth == rhs.IndexWidth);
|
2012-10-10 00:06:12 +08:00
|
|
|
}
|
|
|
|
|
2012-10-05 06:08:14 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2012-10-05 07:01:22 +08:00
|
|
|
// DataLayout Class Implementation
|
2012-10-05 06:08:14 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-01-04 03:21:54 +08:00
|
|
|
const char *DataLayout::getManglingComponent(const Triple &T) {
|
2021-09-25 02:05:55 +08:00
|
|
|
if (T.isOSBinFormatGOFF())
|
|
|
|
return "-m:l";
|
2014-01-04 03:21:54 +08:00
|
|
|
if (T.isOSBinFormatMachO())
|
|
|
|
return "-m:o";
|
2015-03-18 07:54:51 +08:00
|
|
|
if (T.isOSWindows() && T.isOSBinFormatCOFF())
|
|
|
|
return T.getArch() == Triple::x86 ? "-m:x" : "-m:w";
|
2020-07-03 06:45:59 +08:00
|
|
|
if (T.isOSBinFormatXCOFF())
|
|
|
|
return "-m:a";
|
2014-04-03 04:32:05 +08:00
|
|
|
return "-m:e";
|
2014-01-04 03:21:54 +08:00
|
|
|
}
|
|
|
|
|
2013-12-20 23:21:32 +08:00
|
|
|
static const LayoutAlignElem DefaultAlignments[] = {
|
2019-09-27 20:54:21 +08:00
|
|
|
{INTEGER_ALIGN, 1, Align(1), Align(1)}, // i1
|
|
|
|
{INTEGER_ALIGN, 8, Align(1), Align(1)}, // i8
|
|
|
|
{INTEGER_ALIGN, 16, Align(2), Align(2)}, // i16
|
|
|
|
{INTEGER_ALIGN, 32, Align(4), Align(4)}, // i32
|
|
|
|
{INTEGER_ALIGN, 64, Align(4), Align(8)}, // i64
|
[IR][BFloat] Add BFloat IR type
Summary:
The BFloat IR type is introduced to provide support for, initially, the BFloat16
datatype introduced with the Armv8.6 architecture (optional from Armv8.2
onwards). It has an 8-bit exponent and a 7-bit mantissa and behaves like an IEEE
754 floating point IR type.
This is part of a patch series upstreaming Armv8.6 features. Subsequent patches
will upstream intrinsics support and C-lang support for BFloat.
Reviewers: SjoerdMeijer, rjmccall, rsmith, liutianle, RKSimon, craig.topper, jfb, LukeGeeson, sdesmalen, deadalnix, ctetreau
Subscribers: hiraditya, llvm-commits, danielkiss, arphaman, kristof.beyls, dexonsmith
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D78190
2020-04-01 06:49:38 +08:00
|
|
|
{FLOAT_ALIGN, 16, Align(2), Align(2)}, // half, bfloat
|
2019-09-27 20:54:21 +08:00
|
|
|
{FLOAT_ALIGN, 32, Align(4), Align(4)}, // float
|
|
|
|
{FLOAT_ALIGN, 64, Align(8), Align(8)}, // double
|
|
|
|
{FLOAT_ALIGN, 128, Align(16), Align(16)}, // ppcf128, quad, ...
|
|
|
|
{VECTOR_ALIGN, 64, Align(8), Align(8)}, // v2i32, v1i64, ...
|
|
|
|
{VECTOR_ALIGN, 128, Align(16), Align(16)}, // v16i8, v8i16, v4i32, ...
|
|
|
|
{AGGREGATE_ALIGN, 0, Align(1), Align(8)} // struct
|
2013-12-20 07:03:03 +08:00
|
|
|
};
|
|
|
|
|
2014-02-26 06:23:04 +08:00
|
|
|
void DataLayout::reset(StringRef Desc) {
|
|
|
|
clear();
|
|
|
|
|
2014-04-09 14:08:46 +08:00
|
|
|
LayoutMap = nullptr;
|
2014-10-20 18:41:29 +08:00
|
|
|
BigEndian = false;
|
2017-04-11 06:27:50 +08:00
|
|
|
AllocaAddrSpace = 0;
|
2019-08-05 17:00:43 +08:00
|
|
|
StackNaturalAlign.reset();
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
ProgramAddrSpace = 0;
|
2020-11-20 23:17:52 +08:00
|
|
|
DefaultGlobalsAddrSpace = 0;
|
2019-08-05 17:00:43 +08:00
|
|
|
FunctionPtrAlign.reset();
|
2019-03-08 18:44:06 +08:00
|
|
|
TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
|
2014-01-04 03:21:54 +08:00
|
|
|
ManglingMode = MM_None;
|
2016-07-29 07:43:38 +08:00
|
|
|
NonIntegralAddressSpaces.clear();
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Default alignments
|
2014-03-10 23:03:06 +08:00
|
|
|
for (const LayoutAlignElem &E : DefaultAlignments) {
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign,
|
|
|
|
E.PrefAlign, E.TypeBitWidth))
|
|
|
|
return report_fatal_error(std::move(Err));
|
2013-12-20 07:03:03 +08:00
|
|
|
}
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = setPointerAlignment(0, Align(8), Align(8), 8, 8))
|
|
|
|
return report_fatal_error(std::move(Err));
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = parseSpecifier(Desc))
|
|
|
|
return report_fatal_error(std::move(Err));
|
|
|
|
}
|
|
|
|
|
|
|
|
Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) {
|
|
|
|
DataLayout Layout("");
|
|
|
|
if (Error Err = Layout.parseSpecifier(LayoutDescription))
|
|
|
|
return std::move(Err);
|
|
|
|
return Layout;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Error reportError(const Twine &Message) {
|
|
|
|
return createStringError(inconvertibleErrorCode(), Message);
|
2012-11-30 18:06:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Checked version of split, to ensure mandatory subparts.
|
2020-08-17 19:34:07 +08:00
|
|
|
static Error split(StringRef Str, char Separator,
|
|
|
|
std::pair<StringRef, StringRef> &Split) {
|
2012-11-30 18:06:59 +08:00
|
|
|
assert(!Str.empty() && "parse error, string can't be empty here");
|
2020-08-17 19:34:07 +08:00
|
|
|
Split = Str.split(Separator);
|
2014-12-10 09:38:28 +08:00
|
|
|
if (Split.second.empty() && Split.first != Str)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Trailing separator in datalayout string");
|
2014-12-10 10:36:41 +08:00
|
|
|
if (!Split.second.empty() && Split.first.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Expected token before separator in datalayout string");
|
|
|
|
return Error::success();
|
2012-11-14 17:04:56 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2014-01-08 03:51:38 +08:00
|
|
|
/// Get an unsigned integer, including error checks.
|
2020-08-17 19:34:07 +08:00
|
|
|
template <typename IntTy> static Error getInt(StringRef R, IntTy &Result) {
|
2012-11-28 22:32:52 +08:00
|
|
|
bool error = R.getAsInteger(10, Result); (void)error;
|
2014-01-14 06:04:55 +08:00
|
|
|
if (error)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("not a number, or does not fit in an unsigned int");
|
|
|
|
return Error::success();
|
2012-11-28 20:13:12 +08:00
|
|
|
}
|
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
/// Get an unsigned integer representing the number of bits and convert it into
|
|
|
|
/// bytes. Error out of not a byte width multiple.
|
|
|
|
template <typename IntTy>
|
|
|
|
static Error getIntInBytes(StringRef R, IntTy &Result) {
|
|
|
|
if (Error Err = getInt<IntTy>(R, Result))
|
|
|
|
return Err;
|
|
|
|
if (Result % 8)
|
|
|
|
return reportError("number of bits must be a byte width multiple");
|
|
|
|
Result /= 8;
|
|
|
|
return Error::success();
|
2012-11-30 18:06:59 +08:00
|
|
|
}
|
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
static Error getAddrSpace(StringRef R, unsigned &AddrSpace) {
|
|
|
|
if (Error Err = getInt(R, AddrSpace))
|
|
|
|
return Err;
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
if (!isUInt<24>(AddrSpace))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid address space, must be a 24-bit integer");
|
|
|
|
return Error::success();
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
}
|
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
Error DataLayout::parseSpecifier(StringRef Desc) {
|
2020-01-29 03:23:46 +08:00
|
|
|
StringRepresentation = std::string(Desc);
|
2012-10-05 06:08:14 +08:00
|
|
|
while (!Desc.empty()) {
|
2012-11-30 18:06:59 +08:00
|
|
|
// Split at '-'.
|
2020-08-17 19:34:07 +08:00
|
|
|
std::pair<StringRef, StringRef> Split;
|
|
|
|
if (Error Err = split(Desc, '-', Split))
|
|
|
|
return Err;
|
2012-10-05 06:08:14 +08:00
|
|
|
Desc = Split.second;
|
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
// Split at ':'.
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Split.first, ':', Split))
|
|
|
|
return Err;
|
2012-11-30 18:06:59 +08:00
|
|
|
|
|
|
|
// Aliases used below.
|
|
|
|
StringRef &Tok = Split.first; // Current token.
|
|
|
|
StringRef &Rest = Split.second; // The rest of the string.
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2016-07-29 07:43:38 +08:00
|
|
|
if (Tok == "ni") {
|
|
|
|
do {
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
2016-07-29 07:43:38 +08:00
|
|
|
Rest = Split.second;
|
2020-08-17 19:34:07 +08:00
|
|
|
unsigned AS;
|
|
|
|
if (Error Err = getInt(Split.first, AS))
|
|
|
|
return Err;
|
2016-07-29 07:43:38 +08:00
|
|
|
if (AS == 0)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Address space 0 can never be non-integral");
|
2016-07-29 07:43:38 +08:00
|
|
|
NonIntegralAddressSpaces.push_back(AS);
|
|
|
|
} while (!Rest.empty());
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
char Specifier = Tok.front();
|
|
|
|
Tok = Tok.substr(1);
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
switch (Specifier) {
|
2014-01-02 06:29:43 +08:00
|
|
|
case 's':
|
2020-06-26 07:49:07 +08:00
|
|
|
// Deprecated, but ignoring here to preserve loading older textual llvm
|
|
|
|
// ASM file
|
2014-01-02 06:29:43 +08:00
|
|
|
break;
|
2012-10-05 06:08:14 +08:00
|
|
|
case 'E':
|
2014-10-20 18:41:29 +08:00
|
|
|
BigEndian = true;
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
case 'e':
|
2014-10-20 18:41:29 +08:00
|
|
|
BigEndian = false;
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
case 'p': {
|
2012-11-30 18:06:59 +08:00
|
|
|
// Address space.
|
2020-08-17 19:34:07 +08:00
|
|
|
unsigned AddrSpace = 0;
|
|
|
|
if (!Tok.empty())
|
|
|
|
if (Error Err = getInt(Tok, AddrSpace))
|
|
|
|
return Err;
|
2014-12-10 09:17:08 +08:00
|
|
|
if (!isUInt<24>(AddrSpace))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid address space, must be a 24bit integer");
|
2012-11-30 18:06:59 +08:00
|
|
|
|
|
|
|
// Size.
|
2014-12-10 09:38:28 +08:00
|
|
|
if (Rest.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2014-12-10 09:38:28 +08:00
|
|
|
"Missing size specification for pointer in datalayout string");
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
unsigned PointerMemSize;
|
|
|
|
if (Error Err = getIntInBytes(Tok, PointerMemSize))
|
|
|
|
return Err;
|
2015-03-02 14:00:02 +08:00
|
|
|
if (!PointerMemSize)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid pointer size of 0 bytes");
|
2012-11-30 18:06:59 +08:00
|
|
|
|
|
|
|
// ABI alignment.
|
2014-12-10 09:38:28 +08:00
|
|
|
if (Rest.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2014-12-10 09:38:28 +08:00
|
|
|
"Missing alignment specification for pointer in datalayout string");
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
unsigned PointerABIAlign;
|
|
|
|
if (Error Err = getIntInBytes(Tok, PointerABIAlign))
|
|
|
|
return Err;
|
2015-03-02 14:33:51 +08:00
|
|
|
if (!isPowerOf2_64(PointerABIAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Pointer ABI alignment must be a power of 2");
|
2012-11-30 18:06:59 +08:00
|
|
|
|
2018-02-14 14:58:08 +08:00
|
|
|
// Size of index used in GEP for address calculation.
|
|
|
|
// The parameter is optional. By default it is equal to size of pointer.
|
|
|
|
unsigned IndexSize = PointerMemSize;
|
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
// Preferred alignment.
|
|
|
|
unsigned PointerPrefAlign = PointerABIAlign;
|
|
|
|
if (!Rest.empty()) {
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
if (Error Err = getIntInBytes(Tok, PointerPrefAlign))
|
|
|
|
return Err;
|
2015-03-02 14:33:51 +08:00
|
|
|
if (!isPowerOf2_64(PointerPrefAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
|
|
|
"Pointer preferred alignment must be a power of 2");
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2018-02-14 14:58:08 +08:00
|
|
|
// Now read the index. It is the second optional parameter here.
|
|
|
|
if (!Rest.empty()) {
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
if (Error Err = getIntInBytes(Tok, IndexSize))
|
|
|
|
return Err;
|
2018-02-14 14:58:08 +08:00
|
|
|
if (!IndexSize)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid index size of 0 bytes");
|
2018-02-14 14:58:08 +08:00
|
|
|
}
|
|
|
|
}
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = setPointerAlignment(
|
|
|
|
AddrSpace, assumeAligned(PointerABIAlign),
|
|
|
|
assumeAligned(PointerPrefAlign), PointerMemSize, IndexSize))
|
|
|
|
return Err;
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'i':
|
|
|
|
case 'v':
|
|
|
|
case 'f':
|
2014-01-02 06:29:43 +08:00
|
|
|
case 'a': {
|
2012-10-05 06:08:14 +08:00
|
|
|
AlignTypeEnum AlignType;
|
2012-11-30 18:06:59 +08:00
|
|
|
switch (Specifier) {
|
2017-05-23 03:28:36 +08:00
|
|
|
default: llvm_unreachable("Unexpected specifier!");
|
2012-10-05 06:08:14 +08:00
|
|
|
case 'i': AlignType = INTEGER_ALIGN; break;
|
|
|
|
case 'v': AlignType = VECTOR_ALIGN; break;
|
|
|
|
case 'f': AlignType = FLOAT_ALIGN; break;
|
|
|
|
case 'a': AlignType = AGGREGATE_ALIGN; break;
|
|
|
|
}
|
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
// Bit size.
|
2020-08-17 19:34:07 +08:00
|
|
|
unsigned Size = 0;
|
|
|
|
if (!Tok.empty())
|
|
|
|
if (Error Err = getInt(Tok, Size))
|
|
|
|
return Err;
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2014-12-10 09:17:08 +08:00
|
|
|
if (AlignType == AGGREGATE_ALIGN && Size != 0)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2014-12-10 09:17:08 +08:00
|
|
|
"Sized aggregate specification in datalayout string");
|
2014-01-07 05:40:24 +08:00
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
// ABI alignment.
|
2014-12-10 10:36:41 +08:00
|
|
|
if (Rest.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2014-12-10 10:36:41 +08:00
|
|
|
"Missing alignment specification in datalayout string");
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
unsigned ABIAlign;
|
|
|
|
if (Error Err = getIntInBytes(Tok, ABIAlign))
|
|
|
|
return Err;
|
2015-03-02 17:34:59 +08:00
|
|
|
if (AlignType != AGGREGATE_ALIGN && !ABIAlign)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2015-03-02 17:34:59 +08:00
|
|
|
"ABI alignment specification must be >0 for non-aggregate types");
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2019-09-20 21:40:31 +08:00
|
|
|
if (!isUInt<16>(ABIAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid ABI alignment, must be a 16bit integer");
|
2019-09-20 21:40:31 +08:00
|
|
|
if (ABIAlign != 0 && !isPowerOf2_64(ABIAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid ABI alignment, must be a power of 2");
|
2019-09-20 21:40:31 +08:00
|
|
|
|
2012-11-30 18:06:59 +08:00
|
|
|
// Preferred alignment.
|
|
|
|
unsigned PrefAlign = ABIAlign;
|
|
|
|
if (!Rest.empty()) {
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
|
|
|
if (Error Err = getIntInBytes(Tok, PrefAlign))
|
|
|
|
return Err;
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
2012-11-30 18:06:59 +08:00
|
|
|
|
2019-09-20 21:40:31 +08:00
|
|
|
if (!isUInt<16>(PrefAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2019-09-20 21:40:31 +08:00
|
|
|
"Invalid preferred alignment, must be a 16bit integer");
|
|
|
|
if (PrefAlign != 0 && !isPowerOf2_64(PrefAlign))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid preferred alignment, must be a power of 2");
|
2019-09-20 21:40:31 +08:00
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = setAlignment(AlignType, assumeAligned(ABIAlign),
|
|
|
|
assumeAligned(PrefAlign), Size))
|
|
|
|
return Err;
|
2012-10-05 07:01:22 +08:00
|
|
|
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'n': // Native integer types.
|
2017-05-06 06:30:37 +08:00
|
|
|
while (true) {
|
2020-08-17 19:34:07 +08:00
|
|
|
unsigned Width;
|
|
|
|
if (Error Err = getInt(Tok, Width))
|
|
|
|
return Err;
|
2014-12-10 09:17:08 +08:00
|
|
|
if (Width == 0)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2014-12-10 09:17:08 +08:00
|
|
|
"Zero width native integer type in datalayout string");
|
2012-11-28 20:13:12 +08:00
|
|
|
LegalIntWidths.push_back(Width);
|
2012-11-30 18:06:59 +08:00
|
|
|
if (Rest.empty())
|
|
|
|
break;
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = split(Rest, ':', Split))
|
|
|
|
return Err;
|
2012-11-30 18:06:59 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
case 'S': { // Stack natural alignment.
|
2020-08-17 19:34:07 +08:00
|
|
|
uint64_t Alignment;
|
|
|
|
if (Error Err = getIntInBytes(Tok, Alignment))
|
|
|
|
return Err;
|
2019-08-08 01:20:55 +08:00
|
|
|
if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Alignment is neither 0 nor a power of 2");
|
2019-08-08 01:20:55 +08:00
|
|
|
StackNaturalAlign = MaybeAlign(Alignment);
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
}
|
2019-03-08 18:44:06 +08:00
|
|
|
case 'F': {
|
|
|
|
switch (Tok.front()) {
|
|
|
|
case 'i':
|
|
|
|
TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
|
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
TheFunctionPtrAlignType = FunctionPtrAlignType::MultipleOfFunctionAlign;
|
|
|
|
break;
|
|
|
|
default:
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Unknown function pointer alignment type in "
|
2019-03-08 18:44:06 +08:00
|
|
|
"datalayout string");
|
|
|
|
}
|
|
|
|
Tok = Tok.substr(1);
|
2020-08-17 19:34:07 +08:00
|
|
|
uint64_t Alignment;
|
|
|
|
if (Error Err = getIntInBytes(Tok, Alignment))
|
|
|
|
return Err;
|
2019-08-08 01:20:55 +08:00
|
|
|
if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Alignment is neither 0 nor a power of 2");
|
2019-08-08 01:20:55 +08:00
|
|
|
FunctionPtrAlign = MaybeAlign(Alignment);
|
2019-03-08 18:44:06 +08:00
|
|
|
break;
|
|
|
|
}
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
case 'P': { // Function address space.
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = getAddrSpace(Tok, ProgramAddrSpace))
|
|
|
|
return Err;
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
break;
|
|
|
|
}
|
2017-04-11 06:27:50 +08:00
|
|
|
case 'A': { // Default stack/alloca address space.
|
2020-08-17 19:34:07 +08:00
|
|
|
if (Error Err = getAddrSpace(Tok, AllocaAddrSpace))
|
|
|
|
return Err;
|
2017-04-11 06:27:50 +08:00
|
|
|
break;
|
|
|
|
}
|
2020-11-20 23:17:52 +08:00
|
|
|
case 'G': { // Default address space for global variables.
|
|
|
|
if (Error Err = getAddrSpace(Tok, DefaultGlobalsAddrSpace))
|
|
|
|
return Err;
|
|
|
|
break;
|
|
|
|
}
|
2014-01-04 03:21:54 +08:00
|
|
|
case 'm':
|
2014-12-10 10:36:41 +08:00
|
|
|
if (!Tok.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Unexpected trailing characters after mangling "
|
|
|
|
"specifier in datalayout string");
|
2014-12-10 10:36:41 +08:00
|
|
|
if (Rest.empty())
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Expected mangling specifier in datalayout string");
|
2014-12-10 10:36:41 +08:00
|
|
|
if (Rest.size() > 1)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Unknown mangling specifier in datalayout string");
|
2014-01-04 03:21:54 +08:00
|
|
|
switch(Rest[0]) {
|
|
|
|
default:
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Unknown mangling in datalayout string");
|
2014-01-04 03:21:54 +08:00
|
|
|
case 'e':
|
|
|
|
ManglingMode = MM_ELF;
|
|
|
|
break;
|
2021-09-25 02:05:55 +08:00
|
|
|
case 'l':
|
|
|
|
ManglingMode = MM_GOFF;
|
|
|
|
break;
|
2014-01-04 03:21:54 +08:00
|
|
|
case 'o':
|
|
|
|
ManglingMode = MM_MachO;
|
|
|
|
break;
|
|
|
|
case 'm':
|
|
|
|
ManglingMode = MM_Mips;
|
|
|
|
break;
|
2014-01-10 21:42:12 +08:00
|
|
|
case 'w':
|
2015-03-18 07:54:51 +08:00
|
|
|
ManglingMode = MM_WinCOFF;
|
|
|
|
break;
|
|
|
|
case 'x':
|
|
|
|
ManglingMode = MM_WinCOFFX86;
|
2014-01-04 03:21:54 +08:00
|
|
|
break;
|
2020-07-03 06:45:59 +08:00
|
|
|
case 'a':
|
|
|
|
ManglingMode = MM_XCOFF;
|
|
|
|
break;
|
2014-01-04 03:21:54 +08:00
|
|
|
}
|
|
|
|
break;
|
2012-10-05 06:08:14 +08:00
|
|
|
default:
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Unknown specifier in datalayout string");
|
2012-10-05 06:08:14 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-08-17 19:34:07 +08:00
|
|
|
|
|
|
|
return Error::success();
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2017-05-06 06:30:37 +08:00
|
|
|
DataLayout::DataLayout(const Module *M) {
|
2014-09-11 05:27:43 +08:00
|
|
|
init(M);
|
|
|
|
}
|
|
|
|
|
2015-03-05 02:43:29 +08:00
|
|
|
void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2014-02-27 01:02:08 +08:00
|
|
|
bool DataLayout::operator==(const DataLayout &Other) const {
|
2014-10-20 18:41:29 +08:00
|
|
|
bool Ret = BigEndian == Other.BigEndian &&
|
2017-04-11 06:27:50 +08:00
|
|
|
AllocaAddrSpace == Other.AllocaAddrSpace &&
|
2014-02-27 01:02:08 +08:00
|
|
|
StackNaturalAlign == Other.StackNaturalAlign &&
|
Add default address space for functions to the data layout (1/3)
Summary:
This adds initial support for letting targets specify which address
spaces their functions should reside in by default.
If a function is created by a frontend, it will get the default address space specified in the DataLayout, unless the frontend explicitly uses a more general `llvm::Function` constructor. Function address spaces will become a part of the bitcode and textual IR forms, as we do not have access to a data layout whilst parsing LL.
It will be possible to write IR that explicitly has `addrspace(n)` on a function. In this case, the function will reside in the specified space, ignoring the default in the DL.
This is the first step towards placing functions into the correct
address space for Harvard architectures.
Full patchset
* Add program address space to data layout D37052
* Require address space to be specified when creating functions D37054
* [clang] Require address space to be specified when creating functions D37057
Reviewers: pcc, arsenm, kparzysz, hfinkel, theraven
Reviewed By: theraven
Subscribers: arichardson, simoncook, rengolin, wdng, uabelho, bjope, asb, llvm-commits
Differential Revision: https://reviews.llvm.org/D37052
llvm-svn: 325479
2018-02-19 17:56:22 +08:00
|
|
|
ProgramAddrSpace == Other.ProgramAddrSpace &&
|
2020-11-20 23:17:52 +08:00
|
|
|
DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace &&
|
2019-03-08 18:44:06 +08:00
|
|
|
FunctionPtrAlign == Other.FunctionPtrAlign &&
|
|
|
|
TheFunctionPtrAlignType == Other.TheFunctionPtrAlignType &&
|
2014-02-27 01:02:08 +08:00
|
|
|
ManglingMode == Other.ManglingMode &&
|
|
|
|
LegalIntWidths == Other.LegalIntWidths &&
|
2014-04-23 01:47:03 +08:00
|
|
|
Alignments == Other.Alignments && Pointers == Other.Pointers;
|
2015-03-05 02:43:29 +08:00
|
|
|
// Note: getStringRepresentation() might differs, it is not canonicalized
|
2014-02-27 01:02:08 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2017-03-23 14:15:56 +08:00
|
|
|
DataLayout::AlignmentsTy::iterator
|
|
|
|
DataLayout::findAlignmentLowerBound(AlignTypeEnum AlignType,
|
|
|
|
uint32_t BitWidth) {
|
|
|
|
auto Pair = std::make_pair((unsigned)AlignType, BitWidth);
|
2019-06-30 19:19:56 +08:00
|
|
|
return partition_point(Alignments, [=](const LayoutAlignElem &E) {
|
|
|
|
return std::make_pair(E.AlignType, E.TypeBitWidth) < Pair;
|
2019-06-21 13:40:31 +08:00
|
|
|
});
|
2017-03-23 14:15:56 +08:00
|
|
|
}
|
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
Error DataLayout::setAlignment(AlignTypeEnum align_type, Align abi_align,
|
|
|
|
Align pref_align, uint32_t bit_width) {
|
2019-09-20 21:40:31 +08:00
|
|
|
// AlignmentsTy::ABIAlign and AlignmentsTy::PrefAlign were once stored as
|
|
|
|
// uint16_t, it is unclear if there are requirements for alignment to be less
|
|
|
|
// than 2^16 other than storage. In the meantime we leave the restriction as
|
|
|
|
// an assert. See D67400 for context.
|
|
|
|
assert(Log2(abi_align) < 16 && Log2(pref_align) < 16 && "Alignment too big");
|
2015-02-16 13:41:53 +08:00
|
|
|
if (!isUInt<24>(bit_width))
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError("Invalid bit width, must be a 24bit integer");
|
2015-02-16 13:41:53 +08:00
|
|
|
if (pref_align < abi_align)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2015-02-16 13:41:53 +08:00
|
|
|
"Preferred alignment cannot be less than the ABI alignment");
|
|
|
|
|
2017-03-23 14:15:56 +08:00
|
|
|
AlignmentsTy::iterator I = findAlignmentLowerBound(align_type, bit_width);
|
|
|
|
if (I != Alignments.end() &&
|
|
|
|
I->AlignType == (unsigned)align_type && I->TypeBitWidth == bit_width) {
|
|
|
|
// Update the abi, preferred alignments.
|
|
|
|
I->ABIAlign = abi_align;
|
|
|
|
I->PrefAlign = pref_align;
|
|
|
|
} else {
|
|
|
|
// Insert before I to keep the vector sorted.
|
|
|
|
Alignments.insert(I, LayoutAlignElem::get(align_type, abi_align,
|
|
|
|
pref_align, bit_width));
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
2020-08-17 19:34:07 +08:00
|
|
|
return Error::success();
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2020-11-30 04:21:37 +08:00
|
|
|
const PointerAlignElem &
|
|
|
|
DataLayout::getPointerAlignElem(uint32_t AddressSpace) const {
|
|
|
|
if (AddressSpace != 0) {
|
|
|
|
auto I = lower_bound(Pointers, AddressSpace,
|
|
|
|
[](const PointerAlignElem &A, uint32_t AddressSpace) {
|
|
|
|
return A.AddressSpace < AddressSpace;
|
|
|
|
});
|
|
|
|
if (I != Pointers.end() && I->AddressSpace == AddressSpace)
|
|
|
|
return *I;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(Pointers[0].AddressSpace == 0);
|
|
|
|
return Pointers[0];
|
2014-02-27 00:58:35 +08:00
|
|
|
}
|
|
|
|
|
2020-08-17 19:34:07 +08:00
|
|
|
Error DataLayout::setPointerAlignment(uint32_t AddrSpace, Align ABIAlign,
|
|
|
|
Align PrefAlign, uint32_t TypeByteWidth,
|
|
|
|
uint32_t IndexWidth) {
|
2015-02-16 13:41:55 +08:00
|
|
|
if (PrefAlign < ABIAlign)
|
2020-08-17 19:34:07 +08:00
|
|
|
return reportError(
|
2015-02-16 13:41:55 +08:00
|
|
|
"Preferred alignment cannot be less than the ABI alignment");
|
|
|
|
|
2020-11-30 04:21:37 +08:00
|
|
|
auto I = lower_bound(Pointers, AddrSpace,
|
|
|
|
[](const PointerAlignElem &A, uint32_t AddressSpace) {
|
|
|
|
return A.AddressSpace < AddressSpace;
|
|
|
|
});
|
2014-02-27 00:58:35 +08:00
|
|
|
if (I == Pointers.end() || I->AddressSpace != AddrSpace) {
|
|
|
|
Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign,
|
2018-02-14 14:58:08 +08:00
|
|
|
TypeByteWidth, IndexWidth));
|
2012-10-10 00:06:12 +08:00
|
|
|
} else {
|
2014-02-27 00:58:35 +08:00
|
|
|
I->ABIAlign = ABIAlign;
|
|
|
|
I->PrefAlign = PrefAlign;
|
|
|
|
I->TypeByteWidth = TypeByteWidth;
|
2018-02-14 14:58:08 +08:00
|
|
|
I->IndexWidth = IndexWidth;
|
2012-10-10 00:06:12 +08:00
|
|
|
}
|
2020-08-17 19:34:07 +08:00
|
|
|
return Error::success();
|
2012-10-10 00:06:12 +08:00
|
|
|
}
|
|
|
|
|
2020-12-01 01:33:07 +08:00
|
|
|
Align DataLayout::getIntegerAlignment(uint32_t BitWidth,
|
|
|
|
bool abi_or_pref) const {
|
|
|
|
auto I = findAlignmentLowerBound(INTEGER_ALIGN, BitWidth);
|
|
|
|
// If we don't have an exact match, use alignment of next larger integer
|
|
|
|
// type. If there is none, use alignment of largest integer type by going
|
|
|
|
// back one element.
|
|
|
|
if (I == Alignments.end() || I->AlignType != INTEGER_ALIGN)
|
|
|
|
--I;
|
|
|
|
assert(I->AlignType == INTEGER_ALIGN && "Must be integer alignment");
|
|
|
|
return abi_or_pref ? I->ABIAlign : I->PrefAlign;
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class StructLayoutMap {
|
2017-05-06 06:30:37 +08:00
|
|
|
using LayoutInfoTy = DenseMap<StructType*, StructLayout*>;
|
2012-10-05 06:08:14 +08:00
|
|
|
LayoutInfoTy LayoutInfo;
|
|
|
|
|
|
|
|
public:
|
2014-03-10 23:03:06 +08:00
|
|
|
~StructLayoutMap() {
|
2012-10-05 06:08:14 +08:00
|
|
|
// Remove any layouts.
|
2014-03-10 23:03:06 +08:00
|
|
|
for (const auto &I : LayoutInfo) {
|
|
|
|
StructLayout *Value = I.second;
|
2012-10-05 06:08:14 +08:00
|
|
|
Value->~StructLayout();
|
|
|
|
free(Value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-28 01:15:28 +08:00
|
|
|
StructLayout *&operator[](StructType *STy) {
|
2012-10-05 06:08:14 +08:00
|
|
|
return LayoutInfo[STy];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
2014-02-26 06:23:04 +08:00
|
|
|
void DataLayout::clear() {
|
|
|
|
LegalIntWidths.clear();
|
|
|
|
Alignments.clear();
|
|
|
|
Pointers.clear();
|
|
|
|
delete static_cast<StructLayoutMap *>(LayoutMap);
|
2014-04-09 14:08:46 +08:00
|
|
|
LayoutMap = nullptr;
|
2014-02-26 06:23:04 +08:00
|
|
|
}
|
|
|
|
|
2012-10-05 07:01:22 +08:00
|
|
|
DataLayout::~DataLayout() {
|
2014-02-26 06:23:04 +08:00
|
|
|
clear();
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2015-07-28 01:15:28 +08:00
|
|
|
const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
|
2012-10-05 06:08:14 +08:00
|
|
|
if (!LayoutMap)
|
|
|
|
LayoutMap = new StructLayoutMap();
|
|
|
|
|
|
|
|
StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
|
|
|
|
StructLayout *&SL = (*STM)[Ty];
|
|
|
|
if (SL) return SL;
|
|
|
|
|
|
|
|
// Otherwise, create the struct layout. Because it is variable length, we
|
|
|
|
// malloc it, then use placement new.
|
2021-03-31 07:43:12 +08:00
|
|
|
StructLayout *L = (StructLayout *)safe_malloc(
|
|
|
|
StructLayout::totalSizeToAlloc<uint64_t>(Ty->getNumElements()));
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Set SL before calling StructLayout's ctor. The ctor could cause other
|
|
|
|
// entries to be added to TheMap, invalidating our reference.
|
|
|
|
SL = L;
|
|
|
|
|
|
|
|
new (L) StructLayout(Ty, *this);
|
|
|
|
|
|
|
|
return L;
|
|
|
|
}
|
|
|
|
|
2019-09-27 20:54:21 +08:00
|
|
|
Align DataLayout::getPointerABIAlignment(unsigned AS) const {
|
2020-11-30 04:21:37 +08:00
|
|
|
return getPointerAlignElem(AS).ABIAlign;
|
2014-02-27 00:49:40 +08:00
|
|
|
}
|
|
|
|
|
2019-09-27 20:54:21 +08:00
|
|
|
Align DataLayout::getPointerPrefAlignment(unsigned AS) const {
|
2020-11-30 04:21:37 +08:00
|
|
|
return getPointerAlignElem(AS).PrefAlign;
|
2014-02-27 00:49:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned DataLayout::getPointerSize(unsigned AS) const {
|
2020-11-30 04:21:37 +08:00
|
|
|
return getPointerAlignElem(AS).TypeByteWidth;
|
2014-02-27 00:49:40 +08:00
|
|
|
}
|
|
|
|
|
[BasicAA] Support arbitrary pointer sizes (and fix an overflow bug)
Motivated by the discussion in D38499, this patch updates BasicAA to support
arbitrary pointer sizes by switching most remaining non-APInt calculations to
use APInt. The size of these APInts is set to the maximum pointer size (maximum
over all address spaces described by the data layout string).
Most of this translation is straightforward, but this patch contains a fix for
a bug that revealed itself during this translation process. In order for
test/Analysis/BasicAA/gep-and-alias.ll to pass, which is run with 32-bit
pointers, the intermediate calculations must be performed using 64-bit
integers. This is because, as noted in the patch, when GetLinearExpression
decomposes an expression into C1*V+C2, and we then multiply this by Scale, and
distribute, to get (C1*Scale)*V + C2*Scale, it can be the case that, even
through C1*V+C2 does not overflow for relevant values of V, (C2*Scale) can
overflow. If this happens, later logic will draw invalid conclusions from the
(base) offset value. Thus, when initially applying the APInt conversion,
because the maximum pointer size in this test is 32 bits, it started failing.
Suspicious, I created a 64-bit version of this test (included here), and that
failed (miscompiled) on trunk for a similar reason (the multiplication can
overflow).
After fixing this overflow bug, the first test case (at least) in
Analysis/BasicAA/q.bad.ll started failing. This is also a 32-bit test, and was
relying on having 64-bit intermediate values to have BasicAA return an accurate
result. In order to fix this problem, and because I believe that it is not
uncommon to use i64 indexing expressions in 32-bit code (especially portable
code using int64_t), it seems reasonable to always use at least 64-bit
integers. In this way, we won't regress our analysis capabilities (and there's
a command-line option added, so experimenting with this should be easy).
As pointed out by Eli during the review, there are other potential overflow
conditions that this patch does not address. Fixing those is left to follow-up
work.
Patch by me with contributions from Michael Ferguson (mferguson@cray.com).
Differential Revision: https://reviews.llvm.org/D38662
llvm-svn: 350220
2019-01-03 00:28:09 +08:00
|
|
|
unsigned DataLayout::getMaxPointerSize() const {
|
|
|
|
unsigned MaxPointerSize = 0;
|
|
|
|
for (auto &P : Pointers)
|
|
|
|
MaxPointerSize = std::max(MaxPointerSize, P.TypeByteWidth);
|
|
|
|
|
|
|
|
return MaxPointerSize;
|
|
|
|
}
|
|
|
|
|
2015-07-28 01:15:28 +08:00
|
|
|
unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
|
2013-07-27 01:37:20 +08:00
|
|
|
assert(Ty->isPtrOrPtrVectorTy() &&
|
|
|
|
"This should only be called with a pointer or pointer vector type");
|
2017-04-18 02:22:36 +08:00
|
|
|
Ty = Ty->getScalarType();
|
|
|
|
return getPointerSizeInBits(cast<PointerType>(Ty)->getAddressSpace());
|
2013-07-27 01:37:20 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
|
2018-02-14 14:58:08 +08:00
|
|
|
unsigned DataLayout::getIndexSize(unsigned AS) const {
|
2020-11-30 04:21:37 +08:00
|
|
|
return getPointerAlignElem(AS).IndexWidth;
|
2018-02-14 14:58:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned DataLayout::getIndexTypeSizeInBits(Type *Ty) const {
|
|
|
|
assert(Ty->isPtrOrPtrVectorTy() &&
|
|
|
|
"This should only be called with a pointer or pointer vector type");
|
|
|
|
Ty = Ty->getScalarType();
|
|
|
|
return getIndexSizeInBits(cast<PointerType>(Ty)->getAddressSpace());
|
|
|
|
}
|
|
|
|
|
2012-10-05 06:08:14 +08:00
|
|
|
/*!
|
|
|
|
\param abi_or_pref Flag that determines which alignment is returned. true
|
|
|
|
returns the ABI alignment, false returns the preferred alignment.
|
|
|
|
\param Ty The underlying type for which alignment is determined.
|
|
|
|
|
|
|
|
Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
|
|
|
|
== false) for the requested type \a Ty.
|
|
|
|
*/
|
2019-09-27 20:54:21 +08:00
|
|
|
Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
|
2012-10-05 06:08:14 +08:00
|
|
|
assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
|
|
|
|
switch (Ty->getTypeID()) {
|
|
|
|
// Early escape for the non-numeric types.
|
|
|
|
case Type::LabelTyID:
|
2019-09-23 20:41:36 +08:00
|
|
|
return abi_or_pref ? getPointerABIAlignment(0) : getPointerPrefAlignment(0);
|
2012-10-10 00:06:12 +08:00
|
|
|
case Type::PointerTyID: {
|
2014-09-19 06:28:56 +08:00
|
|
|
unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
|
2019-09-23 20:41:36 +08:00
|
|
|
return abi_or_pref ? getPointerABIAlignment(AS)
|
|
|
|
: getPointerPrefAlignment(AS);
|
2012-10-10 00:06:12 +08:00
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
case Type::ArrayTyID:
|
|
|
|
return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
|
|
|
|
|
|
|
|
case Type::StructTyID: {
|
|
|
|
// Packed structure types always have an ABI alignment of one.
|
|
|
|
if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
|
[Alignment][NFC] Deprecate Align::None()
Summary:
This is a follow up on https://reviews.llvm.org/D71473#inline-647262.
There's a caveat here that `Align(1)` relies on the compiler understanding of `Log2_64` implementation to produce good code. One could use `Align()` as a replacement but I believe it is less clear that the alignment is one in that case.
Reviewers: xbolva00, courbet, bollu
Subscribers: arsenm, dylanmckay, sdardis, nemanjai, jvesely, nhaehnle, hiraditya, kbarton, jrtc27, atanasyan, jsji, Jim, kerbowa, cfe-commits, llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D73099
2020-01-21 22:00:04 +08:00
|
|
|
return Align(1);
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Get the layout annotation... which is lazily created on demand.
|
|
|
|
const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
|
2020-12-01 01:33:07 +08:00
|
|
|
const LayoutAlignElem &AggregateAlign = Alignments[0];
|
|
|
|
assert(AggregateAlign.AlignType == AGGREGATE_ALIGN &&
|
|
|
|
"Aggregate alignment must be first alignment entry");
|
|
|
|
const Align Align =
|
|
|
|
abi_or_pref ? AggregateAlign.ABIAlign : AggregateAlign.PrefAlign;
|
2012-10-05 06:08:14 +08:00
|
|
|
return std::max(Align, Layout->getAlignment());
|
|
|
|
}
|
|
|
|
case Type::IntegerTyID:
|
2020-12-01 01:33:07 +08:00
|
|
|
return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref);
|
2012-10-05 06:08:14 +08:00
|
|
|
case Type::HalfTyID:
|
[IR][BFloat] Add BFloat IR type
Summary:
The BFloat IR type is introduced to provide support for, initially, the BFloat16
datatype introduced with the Armv8.6 architecture (optional from Armv8.2
onwards). It has an 8-bit exponent and a 7-bit mantissa and behaves like an IEEE
754 floating point IR type.
This is part of a patch series upstreaming Armv8.6 features. Subsequent patches
will upstream intrinsics support and C-lang support for BFloat.
Reviewers: SjoerdMeijer, rjmccall, rsmith, liutianle, RKSimon, craig.topper, jfb, LukeGeeson, sdesmalen, deadalnix, ctetreau
Subscribers: hiraditya, llvm-commits, danielkiss, arphaman, kristof.beyls, dexonsmith
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D78190
2020-04-01 06:49:38 +08:00
|
|
|
case Type::BFloatTyID:
|
2012-10-05 06:08:14 +08:00
|
|
|
case Type::FloatTyID:
|
|
|
|
case Type::DoubleTyID:
|
|
|
|
// PPC_FP128TyID and FP128TyID have different data contents, but the
|
|
|
|
// same size and alignment, so they look the same here.
|
|
|
|
case Type::PPC_FP128TyID:
|
|
|
|
case Type::FP128TyID:
|
2020-12-01 01:33:07 +08:00
|
|
|
case Type::X86_FP80TyID: {
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(Ty).getFixedSize();
|
|
|
|
auto I = findAlignmentLowerBound(FLOAT_ALIGN, BitWidth);
|
|
|
|
if (I != Alignments.end() && I->AlignType == FLOAT_ALIGN &&
|
|
|
|
I->TypeBitWidth == BitWidth)
|
|
|
|
return abi_or_pref ? I->ABIAlign : I->PrefAlign;
|
|
|
|
|
|
|
|
// If we still couldn't find a reasonable default alignment, fall back
|
|
|
|
// to a simple heuristic that the alignment is the first power of two
|
|
|
|
// greater-or-equal to the store size of the type. This is a reasonable
|
|
|
|
// approximation of reality, and if the user wanted something less
|
|
|
|
// less conservative, they should have specified it explicitly in the data
|
|
|
|
// layout.
|
|
|
|
return Align(PowerOf2Ceil(BitWidth / 8));
|
|
|
|
}
|
2012-10-05 06:08:14 +08:00
|
|
|
case Type::X86_MMXTyID:
|
[SVE] Add new VectorType subclasses
Summary:
Introduce new types for fixed width and scalable vectors.
Does not remove getNumElements yet so as to not break code during transition
period.
Reviewers: deadalnix, efriedma, sdesmalen, craig.topper, huntergr
Reviewed By: sdesmalen
Subscribers: jholewinski, arsenm, jvesely, nhaehnle, mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, nicolasvasilache, csigg, arpith-jacob, mgester, lucyrfox, liufengdb, kerbowa, Joonsoo, grosul1, frgossen, lldb-commits, tschuett, hiraditya, rkruppe, psnobl, llvm-commits
Tags: #llvm, #lldb
Differential Revision: https://reviews.llvm.org/D77587
2020-04-22 23:02:02 +08:00
|
|
|
case Type::FixedVectorTyID:
|
2020-12-01 01:33:07 +08:00
|
|
|
case Type::ScalableVectorTyID: {
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(Ty).getKnownMinSize();
|
|
|
|
auto I = findAlignmentLowerBound(VECTOR_ALIGN, BitWidth);
|
|
|
|
if (I != Alignments.end() && I->AlignType == VECTOR_ALIGN &&
|
|
|
|
I->TypeBitWidth == BitWidth)
|
|
|
|
return abi_or_pref ? I->ABIAlign : I->PrefAlign;
|
|
|
|
|
|
|
|
// By default, use natural alignment for vector types. This is consistent
|
|
|
|
// with what clang and llvm-gcc do.
|
2021-08-01 05:09:59 +08:00
|
|
|
//
|
2020-12-01 01:33:07 +08:00
|
|
|
// We're only calculating a natural alignment, so it doesn't have to be
|
|
|
|
// based on the full size for scalable vectors. Using the minimum element
|
|
|
|
// count should be enough here.
|
2021-08-01 05:09:59 +08:00
|
|
|
return Align(PowerOf2Ceil(getTypeStoreSize(Ty).getKnownMinSize()));
|
2020-12-01 01:33:07 +08:00
|
|
|
}
|
2020-11-20 15:19:34 +08:00
|
|
|
case Type::X86_AMXTyID:
|
|
|
|
return Align(64);
|
2012-10-05 06:08:14 +08:00
|
|
|
default:
|
|
|
|
llvm_unreachable("Bad type for getAlignment!!!");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-23 23:18:34 +08:00
|
|
|
/// TODO: Remove this function once the transition to Align is over.
|
2015-07-28 01:15:28 +08:00
|
|
|
unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
|
2020-01-23 23:18:34 +08:00
|
|
|
return getABITypeAlign(Ty).value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Align DataLayout::getABITypeAlign(Type *Ty) const {
|
|
|
|
return getAlignment(Ty, true);
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2020-01-23 23:18:34 +08:00
|
|
|
/// TODO: Remove this function once the transition to Align is over.
|
2015-07-28 01:15:28 +08:00
|
|
|
unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
|
2020-01-23 23:18:34 +08:00
|
|
|
return getPrefTypeAlign(Ty).value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Align DataLayout::getPrefTypeAlign(Type *Ty) const {
|
|
|
|
return getAlignment(Ty, false);
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2012-10-10 00:06:12 +08:00
|
|
|
IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
|
|
|
|
unsigned AddressSpace) const {
|
2019-12-13 17:55:45 +08:00
|
|
|
return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2015-07-28 01:15:28 +08:00
|
|
|
Type *DataLayout::getIntPtrType(Type *Ty) const {
|
2012-11-01 16:07:29 +08:00
|
|
|
assert(Ty->isPtrOrPtrVectorTy() &&
|
|
|
|
"Expected a pointer or pointer vector type.");
|
2019-12-13 17:55:45 +08:00
|
|
|
unsigned NumBits = getPointerTypeSizeInBits(Ty);
|
2012-10-30 01:31:46 +08:00
|
|
|
IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
|
2015-07-28 01:15:28 +08:00
|
|
|
if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
|
2020-06-22 21:09:34 +08:00
|
|
|
return VectorType::get(IntTy, VecTy);
|
2012-10-30 01:31:46 +08:00
|
|
|
return IntTy;
|
2012-10-24 23:52:52 +08:00
|
|
|
}
|
|
|
|
|
2013-03-22 16:25:01 +08:00
|
|
|
Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
|
2014-03-10 23:03:06 +08:00
|
|
|
for (unsigned LegalIntWidth : LegalIntWidths)
|
|
|
|
if (Width <= LegalIntWidth)
|
|
|
|
return Type::getIntNTy(C, LegalIntWidth);
|
2014-04-09 14:08:46 +08:00
|
|
|
return nullptr;
|
2013-03-22 16:25:01 +08:00
|
|
|
}
|
|
|
|
|
2016-05-14 02:38:35 +08:00
|
|
|
unsigned DataLayout::getLargestLegalIntTypeSizeInBits() const {
|
2014-03-10 23:03:06 +08:00
|
|
|
auto Max = std::max_element(LegalIntWidths.begin(), LegalIntWidths.end());
|
|
|
|
return Max != LegalIntWidths.end() ? *Max : 0;
|
2013-09-17 06:43:16 +08:00
|
|
|
}
|
|
|
|
|
2018-02-14 14:58:08 +08:00
|
|
|
Type *DataLayout::getIndexType(Type *Ty) const {
|
|
|
|
assert(Ty->isPtrOrPtrVectorTy() &&
|
|
|
|
"Expected a pointer or pointer vector type.");
|
|
|
|
unsigned NumBits = getIndexTypeSizeInBits(Ty);
|
|
|
|
IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
|
|
|
|
if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
|
2020-06-18 07:35:35 +08:00
|
|
|
return VectorType::get(IntTy, VecTy);
|
2018-02-14 14:58:08 +08:00
|
|
|
return IntTy;
|
|
|
|
}
|
|
|
|
|
2016-07-13 11:42:38 +08:00
|
|
|
int64_t DataLayout::getIndexedOffsetInType(Type *ElemTy,
|
|
|
|
ArrayRef<Value *> Indices) const {
|
|
|
|
int64_t Result = 0;
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
generic_gep_type_iterator<Value* const*>
|
2016-12-02 10:24:42 +08:00
|
|
|
GTI = gep_type_begin(ElemTy, Indices),
|
|
|
|
GTE = gep_type_end(ElemTy, Indices);
|
2016-01-22 11:08:27 +08:00
|
|
|
for (; GTI != GTE; ++GTI) {
|
|
|
|
Value *Idx = GTI.getOperand();
|
2016-12-02 10:24:42 +08:00
|
|
|
if (StructType *STy = GTI.getStructTypeOrNull()) {
|
2016-01-22 11:30:27 +08:00
|
|
|
assert(Idx->getType()->isIntegerTy(32) && "Illegal struct idx");
|
2016-01-22 11:08:27 +08:00
|
|
|
unsigned FieldNo = cast<ConstantInt>(Idx)->getZExtValue();
|
2012-10-05 06:08:14 +08:00
|
|
|
|
|
|
|
// Get structure layout information...
|
|
|
|
const StructLayout *Layout = getStructLayout(STy);
|
|
|
|
|
|
|
|
// Add in the offset, as calculated by the structure layout info...
|
|
|
|
Result += Layout->getElementOffset(FieldNo);
|
|
|
|
} else {
|
|
|
|
// Get the array index and the size of each array element.
|
2016-01-22 11:08:27 +08:00
|
|
|
if (int64_t arrayIdx = cast<ConstantInt>(Idx)->getSExtValue())
|
2016-07-13 11:42:38 +08:00
|
|
|
Result += arrayIdx * getTypeAllocSize(GTI.getIndexedType());
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2021-09-19 23:32:35 +08:00
|
|
|
static void addElementIndex(SmallVectorImpl<APInt> &Indices, TypeSize ElemSize,
|
|
|
|
APInt &Offset) {
|
2021-09-25 02:42:47 +08:00
|
|
|
// Skip over scalable or zero size elements. Also skip element sizes larger
|
|
|
|
// than the positive index space, because the arithmetic below may not be
|
|
|
|
// correct in that case.
|
|
|
|
unsigned BitWidth = Offset.getBitWidth();
|
|
|
|
if (ElemSize.isScalable() || ElemSize == 0 ||
|
|
|
|
!isUIntN(BitWidth - 1, ElemSize)) {
|
|
|
|
Indices.push_back(APInt::getZero(BitWidth));
|
2021-09-19 23:32:35 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
APInt Index = Offset.sdiv(ElemSize);
|
|
|
|
Offset -= Index * ElemSize;
|
|
|
|
if (Offset.isNegative()) {
|
|
|
|
// Prefer a positive remaining offset to allow struct indexing.
|
|
|
|
--Index;
|
|
|
|
Offset += ElemSize;
|
|
|
|
assert(Offset.isNonNegative() && "Remaining offset shouldn't be negative");
|
|
|
|
}
|
|
|
|
Indices.push_back(Index);
|
|
|
|
}
|
|
|
|
|
|
|
|
SmallVector<APInt> DataLayout::getGEPIndicesForOffset(Type *&ElemTy,
|
|
|
|
APInt &Offset) const {
|
|
|
|
assert(ElemTy->isSized() && "Element type must be sized");
|
|
|
|
SmallVector<APInt> Indices;
|
|
|
|
addElementIndex(Indices, getTypeAllocSize(ElemTy), Offset);
|
|
|
|
while (Offset != 0) {
|
|
|
|
if (auto *ArrTy = dyn_cast<ArrayType>(ElemTy)) {
|
|
|
|
ElemTy = ArrTy->getElementType();
|
|
|
|
addElementIndex(Indices, getTypeAllocSize(ElemTy), Offset);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (auto *VecTy = dyn_cast<VectorType>(ElemTy)) {
|
|
|
|
ElemTy = VecTy->getElementType();
|
|
|
|
unsigned ElemSizeInBits = getTypeSizeInBits(ElemTy).getFixedSize();
|
|
|
|
// GEPs over non-multiple of 8 size vector elements are invalid.
|
|
|
|
if (ElemSizeInBits % 8 != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
addElementIndex(Indices, TypeSize::Fixed(ElemSizeInBits / 8), Offset);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (auto *STy = dyn_cast<StructType>(ElemTy)) {
|
|
|
|
const StructLayout *SL = getStructLayout(STy);
|
|
|
|
uint64_t IntOffset = Offset.getZExtValue();
|
|
|
|
if (IntOffset >= SL->getSizeInBytes())
|
|
|
|
break;
|
|
|
|
|
|
|
|
unsigned Index = SL->getElementContainingOffset(IntOffset);
|
|
|
|
Offset -= SL->getElementOffset(Index);
|
|
|
|
ElemTy = STy->getElementType(Index);
|
|
|
|
Indices.push_back(APInt(32, Index));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Can't index into non-aggregate type.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Indices;
|
|
|
|
}
|
|
|
|
|
2020-06-29 19:24:36 +08:00
|
|
|
/// getPreferredAlign - Return the preferred alignment of the specified global.
|
|
|
|
/// This includes an explicitly requested alignment (if the global has one).
|
|
|
|
Align DataLayout::getPreferredAlign(const GlobalVariable *GV) const {
|
|
|
|
MaybeAlign GVAlignment = GV->getAlign();
|
2018-08-30 07:46:26 +08:00
|
|
|
// If a section is specified, always precisely honor explicit alignment,
|
|
|
|
// so we don't insert padding into a section we don't control.
|
|
|
|
if (GVAlignment && GV->hasSection())
|
2020-06-29 19:24:36 +08:00
|
|
|
return *GVAlignment;
|
2018-08-30 07:46:26 +08:00
|
|
|
|
|
|
|
// If no explicit alignment is specified, compute the alignment based on
|
|
|
|
// the IR type. If an alignment is specified, increase it to match the ABI
|
|
|
|
// alignment of the IR type.
|
|
|
|
//
|
|
|
|
// FIXME: Not sure it makes sense to use the alignment of the type if
|
|
|
|
// there's already an explicit alignment specification.
|
2016-01-17 04:30:46 +08:00
|
|
|
Type *ElemType = GV->getValueType();
|
2020-06-29 19:24:36 +08:00
|
|
|
Align Alignment = getPrefTypeAlign(ElemType);
|
|
|
|
if (GVAlignment) {
|
|
|
|
if (*GVAlignment >= Alignment)
|
|
|
|
Alignment = *GVAlignment;
|
|
|
|
else
|
|
|
|
Alignment = std::max(*GVAlignment, getABITypeAlign(ElemType));
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
|
2018-08-30 07:46:26 +08:00
|
|
|
// If no explicit alignment is specified, and the global is large, increase
|
|
|
|
// the alignment to 16.
|
|
|
|
// FIXME: Why 16, specifically?
|
2020-06-29 19:24:36 +08:00
|
|
|
if (GV->hasInitializer() && !GVAlignment) {
|
|
|
|
if (Alignment < Align(16)) {
|
2012-10-05 06:08:14 +08:00
|
|
|
// If the global is not external, see if it is large. If so, give it a
|
|
|
|
// larger alignment.
|
|
|
|
if (getTypeSizeInBits(ElemType) > 128)
|
2020-06-29 19:24:36 +08:00
|
|
|
Alignment = Align(16); // 16-byte alignment.
|
2012-10-05 06:08:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Alignment;
|
|
|
|
}
|