Changeset 7959e56

Timestamp:

Feb 3, 2025, 1:27:20 PM (7 months ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

dfe8f78

Parents:

59fdd0d

Message:

Eliminate libcfa-build warnings of missing int-to-pointer casts.

Replace a zero_t variable use with literal 0 when it's an argument to an intrinsic and we're generating final C code. Partially revert e0330d2cd1a. Such intrinsics are initialization/assignment of pointers; using the variable implies a missing cast, while using literal 0 needs no cast.

CodeGenerator.hpp
CodeGenerator.cpp

Put attibute unused on all zero_t/one_t object decls. It is needed on those whose uses are rewritten by the rule above.

Generate.cpp

Files:

• src/CodeGen/CodeGenerator.cpp (modified) (4 diffs)
• src/CodeGen/CodeGenerator.hpp (modified) (1 diff)
• src/CodeGen/Generate.cpp (modified) (2 diffs)
• tests/.expect/zero_one-ERR1.txt (added)
• tests/.expect/zero_one.txt (modified) (1 diff)
• tests/Makefile.am (modified) (1 diff)
• tests/zero_one.cfa (modified) (1 diff)

src/CodeGen/CodeGenerator.cpp

@@ -130 +130 @@
         // TODO: Which means the ast::Pass is just providing a default no visit?
         visit_children = false;
+        changeState_ArgToIntrinsic(false);
 }
 
@@ -466 +467 @@
                 if ( var->var->linkage == ast::Linkage::Intrinsic &&
                                 ( opInfo = operatorLookup( var->var->name ) ) ) {
+                        changeState_ArgToIntrinsic(true);
                         auto arg = expr->args.begin();
                         switch ( opInfo->type ) {
@@ -558 +560 @@
         if ( auto name = expr->func.as<ast::NameExpr>() ) {
                 if ( const OperatorInfo * opInfo = operatorLookup( name->name ) ) {
+                        changeState_ArgToIntrinsic(true);
                         auto arg = expr->args.begin();
                         switch ( opInfo->type ) {
@@ -743 +746 @@
         extension( expr );
         const OperatorInfo * opInfo;
-        if ( expr->var->linkage == ast::Linkage::Intrinsic
+        if ( visitingArgToIntrinsic
+                        && options.genC
+                        && dynamic_cast<ast::ZeroType const *>( expr->var->get_type() ) ) {
+                // int * p; p = 0;               ==>  ?=?( p, (zero_t){} );  ==>  p = 0;
+                // void f( zero_t z ) { g(z); }  ==>  g(z);                  ==>  g(z);
+                // (we are at the last '==>')
+                output << "0";
+        } else if ( expr->var->linkage == ast::Linkage::Intrinsic
                         && ( opInfo = operatorLookup( expr->var->name ) )
                         && opInfo->type == OT_CONSTANT ) {

src/CodeGen/CodeGenerator.hpp

@@ -181 +181 @@
         void handleTypedef( ast::NamedTypeDecl const * type );
         std::string mangleName( ast::DeclWithType const * decl );
+
+        bool nextVisitedNodeIsArgToIntrinsic = false;
+        bool visitingArgToIntrinsic = false;
+        void changeState_ArgToIntrinsic( bool newValue ) {
+                GuardValue( visitingArgToIntrinsic ) = nextVisitedNodeIsArgToIntrinsic;
+                GuardValue( nextVisitedNodeIsArgToIntrinsic ) = newValue;
+        }
 };
 

src/CodeGen/Generate.cpp

@@ -46 +46 @@
                 }
         };
+
+        struct ZeroOneObjectHider final {
+                ast::ObjectDecl const * postvisit( ast::ObjectDecl const * decl ) {
+                        if ( decl->type.as<ast::ZeroType>() || decl->type.as<ast::OneType>() ) {
+                                ast::ObjectDecl * mutDecl = ast::mutate( decl );
+                                mutDecl->attributes.push_back( new ast::Attribute( "unused" ) );
+                                return mutDecl;
+                        }
+                        return decl;
+                }
+        };
 } // namespace
 
@@ -52 +63 @@
         erase_if( translationUnit.decls, shouldClean );
         ast::Pass<TreeCleaner>::run( translationUnit );
+        ast::Pass<ZeroOneObjectHider>::run( translationUnit );
 
         ast::Pass<CodeGenerator> cgv( os,

tests/.expect/zero_one.txt

@@ -3 +3 @@
 It's a Number!
 2 2
+0 0
+42 42
+0 0
+1 1
+42 42
+1 1
+zero true
+zero true
+one false
+one false

tests/Makefile.am

@@ -354 +354 @@
         -cp ${test} ${abspath ${@}}
 
+zero_one-ERR1 : zero_one.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+
 ctrl-flow/loop_else : ctrl-flow/loop_else.cfa ${CFACCBIN}
         ${CC} ${AM_CFLAGS} -Wno-superfluous-else $< -o $@ 

tests/zero_one.cfa

@@ -39 +39 @@
 }
 
+void testCompats() {
+    zero_t zero = 0;
+    one_t one = 1;
+
+    int x = 0;
+        int xx = zero;
+
+        sout | x | xx;
+
+        x = xx = 42;
+        sout | x | xx;
+
+        x = 0;
+        xx = zero;
+        sout | x | xx;
+
+        int y = 1;
+        int yy = one;
+
+        sout | y | yy;
+
+        y = yy = 42;
+        sout | y | yy;
+
+        y = 1;
+        yy = one;
+        sout | y | yy;
+
+        void z_helper( int * p, zero_t z ) {
+                p = z;  // expect z not reported unused here; expect no missing cast from -Wint-conversion
+                sout | "zero" | (bool) (p == 0);
+        }
+
+        void z_call( int * p, zero_t z ) {
+                z_helper(p, z);
+        }
+
+        void o_helper( int * p, one_t o ) {
+          #ifdef ERR1
+                p = o;
+          #else
+                (void) x;  (void) o;
+          #endif
+                sout | "one" | (bool) (p == 0);
+        }
+
+        void o_call( int * p, one_t o ) {
+                o_helper(p, o);
+        }
+
+        z_call( &x, 0 );
+        z_call( &x, zero );
+
+        o_call( &x, 1 );
+        o_call( &x, one );
+}
+
 int main() {
         testOverloads();
         testInitAssignQueryIncrement();
+        testCompats();
         return 0;
 }