Skip to content

Commit 569346f

Browse files
aeubanksaeubanks
committed
Revert "Reland [IR] Increase max alignment to 4GB"
This reverts commit 8d64314.
1 parent 1b76312 commit 569346f

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

55 files changed

+170
-179
lines changed

‎clang/lib/CodeGen/CGBlocks.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2695,8 +2695,8 @@ const BlockByrefInfo &CodeGenFunction::getBlockByrefInfo(const VarDecl *D) {
26952695
size = varOffset;
26962696

26972697
// Conversely, we might have to prevent LLVM from inserting padding.
2698-
} else if (CGM.getDataLayout().getABITypeAlignment(varTy) >
2699-
uint64_t(varAlign.getQuantity())) {
2698+
} else if (CGM.getDataLayout().getABITypeAlignment(varTy)
2699+
> varAlign.getQuantity()) {
27002700
packed = true;
27012701
}
27022702
types.push_back(varTy);

‎clang/lib/CodeGen/CGCall.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5021,12 +5021,12 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
50215021
auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType);
50225022

50235023
// Materialize to a temporary.
5024-
addr =
5025-
CreateTempAlloca(RV.getScalarVal()->getType(),
5026-
CharUnits::fromQuantity(std::max(
5027-
layout->getAlignment().value(), scalarAlign)),
5028-
"tmp",
5029-
/*ArraySize=*/nullptr, &AllocaAddr);
5024+
addr = CreateTempAlloca(
5025+
RV.getScalarVal()->getType(),
5026+
CharUnits::fromQuantity(std::max(
5027+
(unsigned)layout->getAlignment().value(), scalarAlign)),
5028+
"tmp",
5029+
/*ArraySize=*/nullptr, &AllocaAddr);
50305030
tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer());
50315031

50325032
Builder.CreateStore(RV.getScalarVal(), addr);

‎clang/lib/CodeGen/CGDecl.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1142,7 +1142,7 @@ Address CodeGenModule::createUnnamedGlobalFrom(const VarDecl &D,
11421142
GV->setAlignment(Align.getAsAlign());
11431143
GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
11441144
CacheEntry = GV;
1145-
} else if (CacheEntry->getAlignment() < uint64_t(Align.getQuantity())) {
1145+
} else if (CacheEntry->getAlignment() < Align.getQuantity()) {
11461146
CacheEntry->setAlignment(Align.getAsAlign());
11471147
}
11481148

‎clang/lib/CodeGen/CodeGenModule.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5386,7 +5386,7 @@ CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
53865386
if (!LangOpts.WritableStrings) {
53875387
Entry = &ConstantStringMap[C];
53885388
if (auto GV = *Entry) {
5389-
if (uint64_t(Alignment.getQuantity()) > GV->getAlignment())
5389+
if (Alignment.getQuantity() > GV->getAlignment())
53905390
GV->setAlignment(Alignment.getAsAlign());
53915391
return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV),
53925392
Alignment);
@@ -5449,7 +5449,7 @@ ConstantAddress CodeGenModule::GetAddrOfConstantCString(
54495449
if (!LangOpts.WritableStrings) {
54505450
Entry = &ConstantStringMap[C];
54515451
if (auto GV = *Entry) {
5452-
if (uint64_t(Alignment.getQuantity()) > GV->getAlignment())
5452+
if (Alignment.getQuantity() > GV->getAlignment())
54535453
GV->setAlignment(Alignment.getAsAlign());
54545454
return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV),
54555455
Alignment);

‎clang/test/CodeGen/builtin-assume-aligned.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ int test6() {
117117
// CHECK-NEXT: store i32* [[A]], i32** [[A_ADDR]], align 8
118118
// CHECK-NEXT: [[TMP0:%.*]] = load i32*, i32** [[A_ADDR]], align 8
119119
// CHECK-NEXT: [[TMP1:%.*]] = bitcast i32* [[TMP0]] to i8*
120-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP1]], i64 4294967296) ]
120+
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP1]], i64 1073741824) ]
121121
// CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
122122
// CHECK-NEXT: store i32* [[TMP2]], i32** [[A_ADDR]], align 8
123123
// CHECK-NEXT: [[TMP3:%.*]] = load i32*, i32** [[A_ADDR]], align 8

‎clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
88

99
char **passthrough(__attribute__((align_value(0x80000000))) char **x) {
10-
// CHECK-NOSANITIZE: define{{.*}} i8** @{{.*}}(i8** align 2147483648 %[[X:.*]])
10+
// CHECK-NOSANITIZE: define{{.*}} i8** @{{.*}}(i8** align 1073741824 %[[X:.*]])
1111
// CHECK-SANITIZE: define{{.*}} i8** @{{.*}}(i8** %[[X:.*]])
1212
// CHECK-NEXT: [[entry:.*]]:
1313
// CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8

‎clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,17 +18,17 @@ void *caller(char **x, unsigned long offset) {
1818
// CHECK-NEXT: %[[OFFSET_RELOADED:.*]] = load i64, i64* %[[OFFSET_ADDR]], align 8
1919
// CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
2020
// CHECK-SANITIZE-NEXT: %[[OFFSETPTR:.*]] = sub i64 %[[PTRINT]], %[[OFFSET_RELOADED]]
21-
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 2147483647
21+
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 1073741823
2222
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
2323
// CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
2424
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
2525
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
26-
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
27-
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
26+
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
27+
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
2828
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
2929
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
3030
// CHECK-SANITIZE: [[CONT]]:
31-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 2147483648, i64 %[[OFFSET_RELOADED]]) ]
31+
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 1073741824, i64 %[[OFFSET_RELOADED]]) ]
3232
// CHECK-NEXT: ret i8* %[[BITCAST]]
3333
// CHECK-NEXT: }
3434
#line 100

‎clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -15,17 +15,17 @@ void *caller(char **x) {
1515
// CHECK-NEXT: %[[BITCAST:.*]] = bitcast i8** %[[X_RELOADED]] to i8*
1616
// CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
1717
// CHECK-SANITIZE-NEXT: %[[OFFSETPTR:.*]] = sub i64 %[[PTRINT]], 42
18-
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 2147483647
18+
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 1073741823
1919
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
2020
// CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
2121
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
2222
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
23-
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 42){{.*}}, !nosanitize
24-
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 42){{.*}}, !nosanitize
23+
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 42){{.*}}, !nosanitize
24+
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 42){{.*}}, !nosanitize
2525
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
2626
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2727
// CHECK-SANITIZE: [[CONT]]:
28-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 2147483648, i64 42) ]
28+
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 1073741824, i64 42) ]
2929
// CHECK-NEXT: ret i8* %[[BITCAST]]
3030
// CHECK-NEXT: }
3131
#line 100

‎clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,17 +14,17 @@ void *caller(char **x) {
1414
// CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
1515
// CHECK-NEXT: %[[BITCAST:.*]] = bitcast i8** %[[X_RELOADED]] to i8*
1616
// CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
17-
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 2147483647
17+
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 1073741823
1818
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
1919
// CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
2020
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
2121
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
22-
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 0){{.*}}, !nosanitize
23-
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 2147483648, i64 0){{.*}}, !nosanitize
22+
// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 0){{.*}}, !nosanitize
23+
// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1073741824, i64 0){{.*}}, !nosanitize
2424
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
2525
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2626
// CHECK-SANITIZE: [[CONT]]:
27-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 2147483648) ]
27+
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 1073741824) ]
2828
// CHECK-NEXT: ret i8* %[[BITCAST]]
2929
// CHECK-NEXT: }
3030
#line 100

‎llvm/include/llvm/Bitcode/BitcodeCommon.h

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -19,14 +19,10 @@
1919
namespace llvm {
2020

2121
struct AllocaPackedValues {
22-
// We increased the number of bits needed to represent alignment to be more
23-
// than 5, but to preserve backward compatibility we store the upper bits
24-
// separately.
25-
using AlignLower = Bitfield::Element<unsigned, 0, 5>;
26-
using UsedWithInAlloca = Bitfield::Element<bool, AlignLower::NextBit, 1>;
22+
using Align = Bitfield::Element<unsigned, 0, 5>;
23+
using UsedWithInAlloca = Bitfield::Element<bool, Align::NextBit, 1>;
2724
using ExplicitType = Bitfield::Element<bool, UsedWithInAlloca::NextBit, 1>;
2825
using SwiftError = Bitfield::Element<bool, ExplicitType::NextBit, 1>;
29-
using AlignUpper = Bitfield::Element<unsigned, SwiftError::NextBit, 3>;
3026
};
3127

3228
} // namespace llvm

‎llvm/include/llvm/IR/DataLayout.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -518,7 +518,7 @@ class DataLayout {
518518

519519
/// Returns the minimum ABI-required alignment for the specified type.
520520
/// FIXME: Deprecate this function once migration to Align is over.
521-
uint64_t getABITypeAlignment(Type *Ty) const;
521+
unsigned getABITypeAlignment(Type *Ty) const;
522522

523523
/// Returns the minimum ABI-required alignment for the specified type.
524524
Align getABITypeAlign(Type *Ty) const;
@@ -541,7 +541,7 @@ class DataLayout {
541541
///
542542
/// This is always at least as good as the ABI alignment.
543543
/// FIXME: Deprecate this function once migration to Align is over.
544-
uint64_t getPrefTypeAlignment(Type *Ty) const;
544+
unsigned getPrefTypeAlignment(Type *Ty) const;
545545

546546
/// Returns the preferred stack/global alignment for the specified
547547
/// type.

‎llvm/include/llvm/IR/GlobalObject.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ class GlobalObject : public GlobalValue {
5151

5252
Comdat *ObjComdat;
5353
enum {
54-
LastAlignmentBit = 5,
54+
LastAlignmentBit = 4,
5555
HasSectionHashEntryBit,
5656

5757
GlobalObjectBits,
@@ -68,7 +68,7 @@ class GlobalObject : public GlobalValue {
6868
GlobalObject(const GlobalObject &) = delete;
6969

7070
/// FIXME: Remove this function once transition to Align is over.
71-
uint64_t getAlignment() const {
71+
unsigned getAlignment() const {
7272
MaybeAlign Align = getAlign();
7373
return Align ? Align->value() : 0;
7474
}

‎llvm/include/llvm/IR/Instruction.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -59,11 +59,11 @@ class Instruction : public User,
5959
// Template alias so that all Instruction storing alignment use the same
6060
// definiton.
6161
// Valid alignments are powers of two from 2^0 to 2^MaxAlignmentExponent =
62-
// 2^32. We store them as Log2(Alignment), so we need 6 bits to encode the 33
62+
// 2^30. We store them as Log2(Alignment), so we need 5 bits to encode the 31
6363
// possible values.
6464
template <unsigned Offset>
6565
using AlignmentBitfieldElementT =
66-
typename Bitfield::Element<unsigned, Offset, 6,
66+
typename Bitfield::Element<unsigned, Offset, 5,
6767
Value::MaxAlignmentExponent>;
6868

6969
template <unsigned Offset>

‎llvm/include/llvm/IR/Instructions.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -126,7 +126,7 @@ class AllocaInst : public UnaryInstruction {
126126
}
127127

128128
// FIXME: Remove this one transition to Align is over.
129-
uint64_t getAlignment() const { return getAlign().value(); }
129+
unsigned getAlignment() const { return getAlign().value(); }
130130

131131
/// Return true if this alloca is in the entry block of the function and is a
132132
/// constant size. If so, the code generator will fold it into the
@@ -217,7 +217,7 @@ class LoadInst : public UnaryInstruction {
217217
/// Return the alignment of the access that is being performed.
218218
/// FIXME: Remove this function once transition to Align is over.
219219
/// Use getAlign() instead.
220-
uint64_t getAlignment() const { return getAlign().value(); }
220+
unsigned getAlignment() const { return getAlign().value(); }
221221

222222
/// Return the alignment of the access that is being performed.
223223
Align getAlign() const {
@@ -348,7 +348,7 @@ class StoreInst : public Instruction {
348348
/// Return the alignment of the access that is being performed
349349
/// FIXME: Remove this function once transition to Align is over.
350350
/// Use getAlign() instead.
351-
uint64_t getAlignment() const { return getAlign().value(); }
351+
unsigned getAlignment() const { return getAlign().value(); }
352352

353353
Align getAlign() const {
354354
return Align(1ULL << (getSubclassData<AlignmentField>()));

‎llvm/include/llvm/IR/Value.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -785,8 +785,8 @@ class Value {
785785
///
786786
/// This is the greatest alignment value supported by load, store, and alloca
787787
/// instructions, and global values.
788-
static constexpr unsigned MaxAlignmentExponent = 32;
789-
static constexpr uint64_t MaximumAlignment = 1ULL << MaxAlignmentExponent;
788+
static constexpr unsigned MaxAlignmentExponent = 30;
789+
static constexpr unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
790790

791791
/// Mutate the type of this Value to be of the specified type.
792792
///

‎llvm/include/llvm/Transforms/IPO/Attributor.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3413,18 +3413,18 @@ struct AADereferenceable
34133413
};
34143414

34153415
using AAAlignmentStateType =
3416-
IncIntegerState<uint64_t, Value::MaximumAlignment, 1>;
3416+
IncIntegerState<uint32_t, Value::MaximumAlignment, 1>;
34173417
/// An abstract interface for all align attributes.
34183418
struct AAAlign : public IRAttribute<
34193419
Attribute::Alignment,
34203420
StateWrapper<AAAlignmentStateType, AbstractAttribute>> {
34213421
AAAlign(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
34223422

34233423
/// Return assumed alignment.
3424-
uint64_t getAssumedAlign() const { return getAssumed(); }
3424+
unsigned getAssumedAlign() const { return getAssumed(); }
34253425

34263426
/// Return known alignment.
3427-
uint64_t getKnownAlign() const { return getKnown(); }
3427+
unsigned getKnownAlign() const { return getKnown(); }
34283428

34293429
/// See AbstractAttribute::getName()
34303430
const std::string getName() const override { return "AAAlign"; }

‎llvm/include/llvm/Transforms/Utils/ASanStackFrameLayout.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ struct ASanStackVariableDescription {
3333
uint64_t Size; // Size of the variable in bytes.
3434
size_t LifetimeSize; // Size in bytes to use for lifetime analysis check.
3535
// Will be rounded up to Granularity.
36-
uint64_t Alignment; // Alignment of the variable (power of 2).
36+
size_t Alignment; // Alignment of the variable (power of 2).
3737
AllocaInst *AI; // The actual AllocaInst.
3838
size_t Offset; // Offset from the beginning of the frame;
3939
// set by ComputeASanStackFrameLayout.

‎llvm/lib/AsmParser/LLParser.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1927,7 +1927,7 @@ bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
19271927
if (!EatIfPresent(lltok::kw_align))
19281928
return false;
19291929
LocTy AlignLoc = Lex.getLoc();
1930-
uint64_t Value = 0;
1930+
uint32_t Value = 0;
19311931

19321932
LocTy ParenLoc = Lex.getLoc();
19331933
bool HaveParens = false;
@@ -1936,13 +1936,13 @@ bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
19361936
HaveParens = true;
19371937
}
19381938

1939-
if (parseUInt64(Value))
1939+
if (parseUInt32(Value))
19401940
return true;
19411941

19421942
if (HaveParens && !EatIfPresent(lltok::rparen))
19431943
return error(ParenLoc, "expected ')'");
19441944

1945-
if (!isPowerOf2_64(Value))
1945+
if (!isPowerOf2_32(Value))
19461946
return error(AlignLoc, "alignment is not a power of two");
19471947
if (Value > Value::MaximumAlignment)
19481948
return error(AlignLoc, "huge alignments are not supported yet");

‎llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4930,10 +4930,8 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
49304930
Type *OpTy = getTypeByID(Record[1]);
49314931
Value *Size = getFnValueByID(Record[2], OpTy);
49324932
MaybeAlign Align;
4933-
uint64_t AlignExp =
4934-
Bitfield::get<APV::AlignLower>(Rec) |
4935-
(Bitfield::get<APV::AlignUpper>(Rec) << APV::AlignLower::Bits);
4936-
if (Error Err = parseAlignmentValue(AlignExp, Align)) {
4933+
if (Error Err =
4934+
parseAlignmentValue(Bitfield::get<APV::Align>(Rec), Align)) {
49374935
return Err;
49384936
}
49394937
if (!Ty || !Size)

‎llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3055,11 +3055,7 @@ void ModuleBitcodeWriter::writeInstruction(const Instruction &I,
30553055
Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
30563056
using APV = AllocaPackedValues;
30573057
unsigned Record = 0;
3058-
unsigned EncodedAlign = getEncodedAlign(AI.getAlign());
3059-
Bitfield::set<APV::AlignLower>(
3060-
Record, EncodedAlign & ((1 << APV::AlignLower::Bits) - 1));
3061-
Bitfield::set<APV::AlignUpper>(Record,
3062-
EncodedAlign >> APV::AlignLower::Bits);
3058+
Bitfield::set<APV::Align>(Record, getEncodedAlign(AI.getAlign()));
30633059
Bitfield::set<APV::UsedWithInAlloca>(Record, AI.isUsedWithInAlloca());
30643060
Bitfield::set<APV::ExplicitType>(Record, true);
30653061
Bitfield::set<APV::SwiftError>(Record, AI.isSwiftError());

0 commit comments

Comments
 (0)