Changeset 2f8d351 for src/GenPoly

Timestamp:

Dec 4, 2023, 10:22:47 AM (7 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

8a4e472

Parents:

4dc3b8c (diff), c4b9fa9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/GenPoly/Box.cpp (modified) (18 diffs)

src/GenPoly/Box.cpp

@@ -40 +40 @@
 namespace {
 
+/// The layout type is used to represent sizes, alignments and offsets.
+ast::BasicType * makeLayoutType() {
+        return new ast::BasicType( ast::BasicType::LongUnsignedInt );
+}
+
+/// Fixed version of layout type (just adding a 'C' in C++ style).
+ast::BasicType * makeLayoutCType() {
+        return new ast::BasicType( ast::BasicType::LongUnsignedInt,
+                ast::CV::Qualifiers( ast::CV::Const ) );
+}
+
 // --------------------------------------------------------------------------
 /// Adds layout-generation functions to polymorphic types.
@@ -60 +71 @@
         }
         return sizedParams;
-}
-
-ast::BasicType * makeSizeAlignType() {
-        return new ast::BasicType( ast::BasicType::LongUnsignedInt );
 }
 
@@ -76 +83 @@
                         sizedParam->location,
                         sizeofName( paramName ),
-                        makeSizeAlignType()
+                        makeLayoutCType()
                 ) );
                 params.emplace_back( new ast::ObjectDecl(
                         sizedParam->location,
                         alignofName( paramName ),
-                        makeSizeAlignType()
+                        makeLayoutCType()
                 ) );
         }
 }
 
-ast::Type * makeSizeAlignOutType() {
-        return new ast::PointerType( makeSizeAlignType() );
+ast::Type * makeLayoutOutType() {
+        return new ast::PointerType( makeLayoutType() );
 }
 
@@ -104 +111 @@
                 location,
                 sizeofName( aggr->name ),
-                makeSizeAlignOutType()
+                makeLayoutOutType()
         );
         ast::ObjectDecl * alignParam = new ast::ObjectDecl(
                 location,
                 alignofName( aggr->name ),
-                makeSizeAlignOutType()
+                makeLayoutOutType()
         );
         ast::ObjectDecl * offsetParam = nullptr;
@@ -117 +124 @@
                         location,
                         offsetofName( aggr->name ),
-                        makeSizeAlignOutType()
+                        makeLayoutOutType()
                 );
                 params.push_back( offsetParam );
@@ -1372 +1379 @@
 };
 
-// size/align/offset parameters may not be used, so add the unused attribute.
 ast::ObjectDecl * makeObj(
                 CodeLocation const & location, std::string const & name ) {
+        // The size/align parameters may be unused, so add the unused attribute.
         return new ast::ObjectDecl( location, name,
-                makeSizeAlignType(),
+                makeLayoutCType(),
                 nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
                 { new ast::Attribute( "unused" ) } );
+}
+
+/// A modified and specialized version of ast::add_qualifiers.
+ast::Type const * addConst( ast::Type const * type ) {
+        ast::CV::Qualifiers cvq = { ast::CV::Const };
+        if ( ( type->qualifiers & cvq ) != 0 ) return type;
+        auto mutType = ast::mutate( type );
+        mutType->qualifiers |= cvq;
+        return mutType;
 }
 
@@ -1418 +1434 @@
         }
         for ( ast::ptr<ast::DeclWithType> & assert : mutDecl->assertions ) {
+                ast::DeclWithType * mutAssert = ast::mutate( assert.get() );
                 // Assertion parameters may not be used in body,
                 // pass along with unused attribute.
-                assert.get_and_mutate()->attributes.push_back(
-                        new ast::Attribute( "unused" ) );
-                inferredParams.push_back( assert );
+                mutAssert->attributes.push_back( new ast::Attribute( "unused" ) );
+                mutAssert->set_type( addConst( mutAssert->get_type() ) );
+                inferredParams.emplace_back( mutAssert );
         }
         mutDecl->assertions.clear();
@@ -1609 +1626 @@
 
 /// Converts polymorphic type into a suitable monomorphic representation.
-/// Currently: __attribute__((aligned(8) )) char[size_T];
+/// Currently: __attribute__(( aligned(8) )) char[size_T];
 ast::Type * polyToMonoType( CodeLocation const & location,
                 ast::Type const * declType ) {
@@ -1615 +1632 @@
         auto size = new ast::NameExpr( location,
                 sizeofName( Mangle::mangleType( declType ) ) );
-        auto aligned = new ast::Attribute( "aligned",
-                { ast::ConstantExpr::from_int( location, 8 ) } );
         auto ret = new ast::ArrayType( charType, size,
                 ast::VariableLen, ast::DynamicDim, ast::CV::Qualifiers() );
-        ret->attributes.push_back( aligned );
+        ret->attributes.emplace_back( new ast::Attribute( "aligned",
+                { ast::ConstantExpr::from_int( location, 8 ) } ) );
         return ret;
 }
@@ -1645 +1661 @@
         ast::TypeInstType inst( decl->name, decl );
         std::string typeName = Mangle::mangleType( &inst );
-        ast::Type * layoutType = new ast::BasicType(
-                ast::BasicType::LongUnsignedInt );
 
         ast::ObjectDecl * sizeDecl = new ast::ObjectDecl( decl->location,
-                sizeofName( typeName ), layoutType,
+                sizeofName( typeName ), makeLayoutCType(),
                 new ast::SingleInit( decl->location,
                         new ast::SizeofExpr( decl->location, deepCopy( base ) )
@@ -1655 +1669 @@
         );
         ast::ObjectDecl * alignDecl = new ast::ObjectDecl( decl->location,
-                alignofName( typeName ), layoutType,
+                alignofName( typeName ), makeLayoutCType(),
                 new ast::SingleInit( decl->location,
                         new ast::AlignofExpr( decl->location, deepCopy( base ) )
@@ -1752 +1766 @@
 long findMember( ast::DeclWithType const * memberDecl,
                 const ast::vector<ast::Decl> & baseDecls ) {
-        for ( auto pair : enumerate( baseDecls ) ) {
-                if ( isMember( memberDecl, pair.val.get() ) ) {
-                        return pair.idx;
+        for ( auto const & [index, value] : enumerate( baseDecls ) ) {
+                if ( isMember( memberDecl, value.get() ) ) {
+                        return index;
                 }
         }
@@ -1912 +1926 @@
         knownOffsets.insert( offsetName );
 
-        auto baseMembers = type->base->members;
-        ast::Type const * offsetType = new ast::BasicType(
-                ast::BasicType::LongUnsignedInt );
-
         // Build initializer list for offset array.
         ast::vector<ast::Init> inits;
-        for ( ast::ptr<ast::Decl> & member : baseMembers ) {
+        for ( ast::ptr<ast::Decl> const & member : type->base->members ) {
                 auto memberDecl = member.as<ast::DeclWithType>();
                 assertf( memberDecl, "Requesting offset of non-DWT member: %s",
@@ -1932 +1942 @@
         auto offsetArray = makeVar( expr->location, offsetName,
                 new ast::ArrayType(
-                        offsetType,
-                        ast::ConstantExpr::from_ulong( expr->location, baseMembers.size() ),
+                        makeLayoutType(),
+                        ast::ConstantExpr::from_ulong( expr->location, inits.size() ),
                         ast::FixedLen,
                         ast::DynamicDim
@@ -2012 +2022 @@
                 // parameters to the layout call.
                 knownLayouts.insert( typeName );
-                ast::Type const * layoutType = makeSizeAlignType();
 
                 int memberCount = inst->base->members.size();
@@ -2018 +2027 @@
                         // All empty structures have the same layout (size 1, align 1).
                         makeVar( location,
-                                sizeofName( typeName ), layoutType,
+                                sizeofName( typeName ), makeLayoutType(),
                                 new ast::SingleInit( location,
                                                 ast::ConstantExpr::from_ulong( location, 1 ) ) );
                         makeVar( location,
-                                alignofName( typeName ), ast::deepCopy( layoutType ),
+                                alignofName( typeName ), makeLayoutType(),
                                 new ast::SingleInit( location,
                                                 ast::ConstantExpr::from_ulong( location, 1 ) ) );
@@ -2028 +2037 @@
                 } else {
                         ast::ObjectDecl const * sizeofVar = makeVar( location,
-                                sizeofName( typeName ), deepCopy( layoutType ), nullptr );
+                                sizeofName( typeName ), makeLayoutType(), nullptr );
                         ast::ObjectDecl const * alignofVar = makeVar( location,
-                                alignofName( typeName ), deepCopy( layoutType ), nullptr );
+                                alignofName( typeName ), makeLayoutType(), nullptr );
                         ast::ObjectDecl const * offsetofVar = makeVar( location,
                                 offsetofName( typeName ),
                                 new ast::ArrayType(
-                                        layoutType,
+                                        makeLayoutType(),
                                         ast::ConstantExpr::from_int( location, memberCount ),
                                         ast::FixedLen,
@@ -2078 +2087 @@
                 // parameters to the layout call.
                 knownLayouts.insert( typeName );
-                ast::Type const * layoutType = makeSizeAlignType();
 
                 ast::ObjectDecl * sizeofVar = makeVar( location,
-                        sizeofName( typeName ), layoutType );
+                        sizeofName( typeName ), makeLayoutType() );
                 ast::ObjectDecl * alignofVar = makeVar( location,
-                        alignofName( typeName ), ast::deepCopy( layoutType ) );
+                        alignofName( typeName ), makeLayoutType() );
 
                 ast::UntypedExpr * layoutCall = new ast::UntypedExpr( location,