[flang][NFC] Replace "align" with "alignment"

[tskeith]

Summary

In the places it is used as a noun, replace "align" with "alignment".

[jdoerfert]

Seems reasonable, LGTM.

flang/include/flang/Semantics/scope.h

public:
   const DeclTypeSpec &MakeClassStarType();
 
   // For modules read from module files, this is the stream of characters
   // that are referenced by SourceName objects.
   void set_chars(parser::CookedSource &);
 
   std::size_t size() const { return size_; }
   void set_size(std::size_t size) { size_ = size; }
-  std::size_t align() const { return align_; }
-  void set_align(std::size_t align) { align_ = align; }
+  std::size_t alignment() const { return alignment_; }
+  void set_alignment(std::size_t alignment) { alignment_ = alignment; }
 
   ImportKind GetImportKind() const;
   // Names appearing in IMPORT statements in this scope
   std::set<SourceName> importNames() const { return importNames_; }
 
   // Set the kind of imports from host into this scope.
   // Return an error message for incompatible kinds.
   std::optional<parser::MessageFixedText> SetImportKind(ImportKind);
public:
   }
 
   void InstantiateDerivedTypes(SemanticsContext &);
 
 private:
   Scope &parent_; // this is enclosing scope, not extended derived type base
   const Kind kind_;
   std::size_t size_{0}; // size in bytes
-  std::size_t align_{0}; // required alignment in bytes
+  std::size_t alignment_{0}; // required alignment in bytes
   parser::CharBlock sourceRange_;
   Symbol *const symbol_; // if not null, symbol_->scope() == this
   std::list<Scope> children_;
   mapType symbols_;
   mapType commonBlocks_;
   std::list<EquivalenceSet> equivalenceSets_;
   mapType crayPointers_;
   std::map<SourceName, common::Reference<Scope>> submodules_;

flang/include/flang/Semantics/symbol.h

 
 class CommonBlockDetails {
 public:
   MutableSymbolVector &objects() { return objects_; }
   const MutableSymbolVector &objects() const { return objects_; }
   void add_object(Symbol &object) { objects_.emplace_back(object); }
   MaybeExpr bindName() const { return bindName_; }
   void set_bindName(MaybeExpr &&expr) { bindName_ = std::move(expr); }
-  std::size_t align() const { return align_; }
-  void set_align(std::size_t align) { align_ = align; }
+  std::size_t alignment() const { return alignment_; }
+  void set_alignment(std::size_t alignment) { alignment_ = alignment; }
 
 private:
   MutableSymbolVector objects_;
   MaybeExpr bindName_;
-  std::size_t align_{0}; // required alignment in bytes
+  std::size_t alignment_{0}; // required alignment in bytes
 };
 
 class FinalProcDetails {}; // TODO
 
 class MiscDetails {
 public:
   ENUM_CLASS(Kind, None, ConstructName, ScopeName, PassName, ComplexPartRe,
       ComplexPartIm, KindParamInquiry, LenParamInquiry, SelectTypeAssociateName,

flang/lib/Semantics/compute-offsets.cpp

 public:
   // TODO: configure based on target
   static constexpr int maxAlignment{8};
 
   ComputeOffsetsHelper(SemanticsContext &context) : context_{context} {}
   void Compute() { Compute(context_.globalScope()); }
 
 private:
-  struct SizeAndAlign {
-    SizeAndAlign() {}
-    SizeAndAlign(std::size_t size) : size{size}, align{size} {}
-    SizeAndAlign(std::size_t size, std::size_t align)
-        : size{size}, align{align} {}
+  struct SizeAndAlignment {
+    SizeAndAlignment() {}
+    SizeAndAlignment(std::size_t size) : size{size}, alignment{size} {}
+    SizeAndAlignment(std::size_t size, std::size_t alignment)
+        : size{size}, alignment{alignment} {}
     std::size_t size{0};
-    std::size_t align{0};
+    std::size_t alignment{0};
   };
   struct SymbolAndOffset {
     Symbol *symbol{nullptr};
     std::size_t offset{0};
   };
 
   void Compute(Scope &);
   void DoScope(Scope &);
   void DoCommonBlock(Symbol &);
   void DoEquivalenceSet(EquivalenceSet &);
   std::size_t GetOffset(SymbolAndOffset &);
   std::size_t ComputeOffset(const EquivalenceObject &);
   void DoSymbol(Symbol &);
-  SizeAndAlign GetSizeAndAlign(const Symbol &);
-  SizeAndAlign GetElementSize(const Symbol &, bool isSubstring = false);
+  SizeAndAlignment GetSizeAndAlignment(const Symbol &);
+  SizeAndAlignment GetElementSize(const Symbol &, bool isSubstring = false);
   std::size_t CountElements(const Symbol &);
   static std::size_t Align(std::size_t, std::size_t);
-  static SizeAndAlign GetIntrinsicSizeAndAlign(TypeCategory, int);
+  static SizeAndAlignment GetIntrinsicSizeAndAlignment(TypeCategory, int);
 
   SemanticsContext &context_;
   evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
   std::size_t offset_{0};
-  std::size_t align_{0};
+  std::size_t alignment_{0};
   // symbol -> symbol+offset that determines its location, from EQUIVALENCE
   std::map<MutableSymbolRef, SymbolAndOffset> dependents_;
 };
 
 void ComputeOffsetsHelper::Compute(Scope &scope) {
   for (Scope &child : scope.children()) {
     Compute(child);
   }
void ComputeOffsetsHelper::DoScope(Scope &scope) {
   for (auto &pair : scope.commonBlocks()) {
     DoCommonBlock(*pair.second);
   }
   // Build dependents_ from equivalences: symbol -> symbol+offset
   for (EquivalenceSet &set : scope.equivalenceSets()) {
     DoEquivalenceSet(set);
   }
   offset_ = 0;
-  align_ = 0;
+  alignment_ = 0;
   for (auto &symbol : scope.GetSymbols()) {
     if (!InCommonBlock(*symbol) &&
         dependents_.find(symbol) == dependents_.end()) {
       DoSymbol(*symbol);
     }
   }
   for (auto &[symbol, dep] : dependents_) {
     if (symbol->size() == 0) {
-      SizeAndAlign s{GetSizeAndAlign(*symbol)};
+      SizeAndAlignment s{GetSizeAndAlignment(*symbol)};
       symbol->set_size(s.size);
       symbol->set_offset(GetOffset(dep));
       offset_ = std::max(offset_, symbol->offset() + symbol->size());
     }
   }
   scope.set_size(offset_);
-  scope.set_align(align_);
+  scope.set_alignment(alignment_);
 }
 
 std::size_t ComputeOffsetsHelper::GetOffset(SymbolAndOffset &dep) {
   auto it{dependents_.find(*dep.symbol)};
   if (it == dependents_.end()) {
     return dep.symbol->offset() + dep.offset;
   } else {
     return GetOffset(it->second) + dep.offset;
   }
 }
 
 void ComputeOffsetsHelper::DoCommonBlock(Symbol &commonBlock) {
   auto &details{commonBlock.get<CommonBlockDetails>()};
   offset_ = 0;
-  align_ = 0;
+  alignment_ = 0;
   for (auto &object : details.objects()) {
     DoSymbol(*object);
   }
   commonBlock.set_size(offset_);
-  details.set_align(align_);
+  details.set_alignment(alignment_);
 }
 
 void ComputeOffsetsHelper::DoEquivalenceSet(EquivalenceSet &set) {
   std::vector<SymbolAndOffset> symbolOffsets;
   SymbolAndOffset max;
   for (EquivalenceObject &object : set) {
     std::size_t offset{ComputeOffset(object)};
     symbolOffsets.push_back({&object.symbol, offset});
return offset *
       GetElementSize(object.symbol, object.substringStart.has_value()).size;
 }
 
 void ComputeOffsetsHelper::DoSymbol(Symbol &symbol) {
   if (symbol.has<TypeParamDetails>() || symbol.has<SubprogramDetails>() ||
       symbol.has<UseDetails>() || symbol.has<ProcBindingDetails>()) {
     return; // these have type but no size
   }
-  SizeAndAlign s{GetSizeAndAlign(symbol)};
+  SizeAndAlignment s{GetSizeAndAlignment(symbol)};
   if (s.size == 0) {
     return;
   }
-  offset_ = Align(offset_, s.align);
+  offset_ = Align(offset_, s.alignment);
   symbol.set_size(s.size);
   symbol.set_offset(offset_);
   offset_ += s.size;
-  align_ = std::max(align_, s.align);
+  alignment_ = std::max(alignment_, s.alignment);
 }
 
-auto ComputeOffsetsHelper::GetSizeAndAlign(const Symbol &symbol)
-    -> SizeAndAlign {
-  SizeAndAlign result{GetElementSize(symbol)};
+auto ComputeOffsetsHelper::GetSizeAndAlignment(const Symbol &symbol)
+    -> SizeAndAlignment {
+  SizeAndAlignment result{GetElementSize(symbol)};
   std::size_t elements{CountElements(symbol)};
   if (elements > 1) {
-    result.size = Align(result.size, result.align);
+    result.size = Align(result.size, result.alignment);
   }
   result.size *= elements;
   return result;
 }
 
 auto ComputeOffsetsHelper::GetElementSize(
-    const Symbol &symbol, bool isSubstring) -> SizeAndAlign {
+    const Symbol &symbol, bool isSubstring) -> SizeAndAlignment {
   const DeclTypeSpec *type{symbol.GetType()};
   if (!type) {
     return {};
   }
   if (IsDescriptor(symbol) || IsProcedure(symbol)) {
     int lenParams{0};
     if (const DerivedTypeSpec * derived{type->AsDerived()}) {
       lenParams = derived->NumLengthParameters();
     }
     std::size_t size{
         runtime::Descriptor::SizeInBytes(symbol.Rank(), false, lenParams)};
     return {size, maxAlignment};
   }
-  SizeAndAlign result;
+  SizeAndAlignment result;
   if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
     if (auto kind{ToInt64(intrinsic->kind())}) {
-      result = GetIntrinsicSizeAndAlign(intrinsic->category(), *kind);
+      result = GetIntrinsicSizeAndAlignment(intrinsic->category(), *kind);
     }
     if (!isSubstring && type->category() == DeclTypeSpec::Character) {
       ParamValue length{type->characterTypeSpec().length()};
       CHECK(length.isExplicit()); // else should be descriptor
       if (MaybeIntExpr lengthExpr{length.GetExplicit()}) {
         if (auto lengthInt{ToInt64(*lengthExpr)}) {
           result.size *= *lengthInt;
         }
       }
     }
   } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
     if (derived->scope()) {
       result.size = derived->scope()->size();
-      result.align = derived->scope()->align();
+      result.alignment = derived->scope()->alignment();
     }
   } else {
     DIE("not intrinsic or derived");
   }
   return result;
 }
 
 std::size_t ComputeOffsetsHelper::CountElements(const Symbol &symbol) {

 // Align a size to its natural alignment, up to maxAlignment.
 std::size_t ComputeOffsetsHelper::Align(std::size_t x, std::size_t alignment) {
   if (alignment > maxAlignment) {
     alignment = maxAlignment;
   }
   return (x + alignment - 1) & -alignment;
 }
 
-auto ComputeOffsetsHelper::GetIntrinsicSizeAndAlign(
-    TypeCategory category, int kind) -> SizeAndAlign {
+auto ComputeOffsetsHelper::GetIntrinsicSizeAndAlignment(
+    TypeCategory category, int kind) -> SizeAndAlignment {
   // TODO: does kind==10 need special handling?
   std::size_t size{kind == 3 ? 2 : static_cast<std::size_t>(kind)};
   if (category == TypeCategory::Complex) {
     return {2 * size, size};
   } else {
     return {size};
   }
 }
 
 void ComputeOffsets(SemanticsContext &context) {
   ComputeOffsetsHelper{context}.Compute();
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/semantics.cpp

 
 void DoDumpSymbols(llvm::raw_ostream &os, const Scope &scope, int indent) {
   PutIndent(os, indent);
   os << Scope::EnumToString(scope.kind()) << " scope:";
   if (const auto *symbol{scope.symbol()}) {
     os << ' ' << symbol->name();
   }
   if (scope.size()) {
-    os << " size=" << scope.size() << " align=" << scope.align();
+    os << " size=" << scope.size() << " alignment=" << scope.alignment();
   }
   if (scope.derivedTypeSpec()) {
     os << " instantiation of " << *scope.derivedTypeSpec();
   }
   os << '\n';
   ++indent;
   for (const auto &pair : scope) {
     const auto &symbol{*pair.second};

flang/lib/Semantics/symbol.cpp

std::visit(
             os << " => " << x.symbol().name();
             DumpOptional(os, "passName", x.passName());
           },
           [&](const NamelistDetails &x) {
             os << ':';
             DumpSymbolVector(os, x.objects());
           },
           [&](const CommonBlockDetails &x) {
-            if (x.align()) {
-              os << " align=" << x.align();
+            if (x.alignment()) {
+              os << " alignment=" << x.alignment();
             }
             os << ':';
             for (const auto &object : x.objects()) {
               os << ' ' << object->name();
             }
           },
           [&](const FinalProcDetails &) {},
           [&](const TypeParamDetails &x) {

flang/test/Semantics/offsets02.f90

subroutine s3
   type :: t(k, l)
     integer, kind :: k
     integer, len :: l
     real(k) :: a3
     integer(kind=k) :: b3
     character(kind=k, len=8) :: c3
     character(kind=k, len=l) :: d3
   end type
-  !CHECK: DerivedType scope: size=48 align=8 instantiation of t(k=2_4,l=10_4)
+  !CHECK: DerivedType scope: size=48 alignment=8 instantiation of t(k=2_4,l=10_4)
   !CHECK: a3 size=2 offset=0:
   !CHECK: b3 size=2 offset=2:
   !CHECK: c3 size=16 offset=4:
   !CHECK: d3 size=24 offset=24:
   type(t(2, 10)) :: x3
-  !CHECK: DerivedType scope: size=64 align=8 instantiation of t(k=4_4,l=20_4)
+  !CHECK: DerivedType scope: size=64 alignment=8 instantiation of t(k=4_4,l=20_4)
   !CHECK: a3 size=4 offset=0:
   !CHECK: b3 size=4 offset=4:
   !CHECK: c3 size=32 offset=8:
   !CHECK: d3 size=24 offset=40:
   type(t(4, 20)) :: x4
 end

flang/test/Semantics/offsets03.f90

module mb
   real :: b(-1:1,2:6)     !CHECK: b, PUBLIC size=60 offset=0:
   equivalence(b(1,6), b1) !CHECK: b1, PUBLIC size=16 offset=56:
   equivalence(b(1,5), b2) !CHECK: b2, PUBLIC size=4 offset=44:
   equivalence(b(0,6), b3) !CHECK: b3, PUBLIC size=4 offset=52:
   equivalence(b(0,4), b4) !CHECK: b4, PUBLIC size=4 offset=28:
 end
 
 ! equivalence and substring
-subroutine mc         !CHECK: Subprogram scope: mc size=12 align=1
+subroutine mc         !CHECK: Subprogram scope: mc size=12 alignment=1
   character(10) :: c1 !CHECK: c1 size=10 offset=0:
   character(5)  :: c2 !CHECK: c2 size=5 offset=7:
   equivalence(c1(9:), c2(2:4))
 end
 
 ! Common block: objects are in order from COMMON statement and not part of module
-module md                   !CHECK: Module scope: md size=1 align=1
+module md                   !CHECK: Module scope: md size=1 alignment=1
   integer(1) :: i 
   integer(2) :: d1          !CHECK: d1, PUBLIC size=2 offset=8:
   integer(4) :: d2          !CHECK: d2, PUBLIC size=4 offset=4:
   integer(1) :: d3          !CHECK: d3, PUBLIC size=1 offset=0:
   real(2) :: d4             !CHECK: d4, PUBLIC size=2 offset=0:
-  common /common1/ d3,d2,d1 !CHECK: common1 size=10 offset=0: CommonBlockDetails align=4:
-  common /common2/ d4       !CHECK: common2 size=2 offset=0: CommonBlockDetails align=2:
+  common /common1/ d3,d2,d1 !CHECK: common1 size=10 offset=0: CommonBlockDetails alignment=4:
+  common /common2/ d4       !CHECK: common2 size=2 offset=0: CommonBlockDetails alignment=2:
 end