Changeset 11546


Ignore:
Timestamp:
Sep 1, 2018 1:51:49 PM (16 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Unused global variables removed by cleanup step

Location:
trunk/Compiler
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r11543 r11546  
    3939                    block.genSetupNodeDecls_C(p, str, indent);
    4040                }
    41                 for (FVariable fv : fclass.getGlobalVariables()) {
     41                for (FVariable fv : fclass.getFGlobalVariables()) {
    4242                    fv.genGlobalVariableDecl_C(p, str, indent);
    4343                }
     
    282282               
    283283                ArrayList<FVariable> globals = new ArrayList<FVariable>();
    284                 for (FVariable fv : fclass.getGlobalVariables()) {
     284                for (FVariable fv : fclass.getFGlobalVariables()) {
    285285                    globals.add(fv);
    286286                }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatNameBinding.jrag

    r11543 r11546  
    111111   
    112112    syn lazy FlatVariableMap FClass.variablesMap()        = new FlatVariableMap(getFVariables(), getAliasVariables());
    113     syn lazy FlatVariableMap FClass.globalVariablesMap() = new FlatVariableMap(getGlobalVariables());
     113    syn lazy FlatVariableMap FClass.globalVariablesMap() = new FlatVariableMap(getFGlobalVariables());
    114114    syn lazy FlatVariableMap FFunctionDecl.variablesMap() = new FlatVariableMap(getFFunctionVariables());
    115115    syn lazy FlatVariableMap FRecordDecl.variablesMap()   = new FlatVariableMap(getFVariables());
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r11543 r11546  
    10031003            }
    10041004        }
    1005         if (getNumGlobalVariable() > 0) {
     1005        if (getNumFGlobalVariable() > 0) {
    10061006            str.println(indent, "package constant");
    1007             for (FVariable fv : getGlobalVariables()) {
     1007            for (FVariable fv : getFGlobalVariables()) {
    10081008                p.print(fv, str, nextInd);
    10091009                str.println(";");
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r11543 r11546  
    3131                      FVariable*
    3232                      AliasVariable:FVariable*
    33                       GlobalVariable:FVariable*
     33                      FGlobalVariable*
    3434                      FInitialEquation:FAbstractEquation*
    3535                      ParameterEquation:FAbstractEquation*
  • trunk/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r11543 r11546  
    42184218 constant Real r[2].x = 2;
    42194219 constant Real y = 6.0;
    4220 package constant
    4221  constant EvaluationTests.ConstantInFunction1.R EvaluationTests.ConstantInFunction1.r[2] = {EvaluationTests.ConstantInFunction1.R(1), EvaluationTests.ConstantInFunction1.R(2)};
    4222 
    4223 public
    4224  record EvaluationTests.ConstantInFunction1.R
    4225   Real x;
    4226  end EvaluationTests.ConstantInFunction1.R;
    4227 
    42284220end EvaluationTests.ConstantInFunction1;
    42294221")})));
     
    42574249 constant Real y1 = 4.0;
    42584250 constant Real y2 = 2.0;
    4259 package constant
    4260  constant EvaluationTests.ConstantInFunction2.R EvaluationTests.ConstantInFunction2.r[2] = {EvaluationTests.ConstantInFunction2.R(1), EvaluationTests.ConstantInFunction2.R(2)};
    4261 
    4262 public
    4263  record EvaluationTests.ConstantInFunction2.R
    4264   Real x;
    4265  end EvaluationTests.ConstantInFunction2.R;
    4266 
    42674251end EvaluationTests.ConstantInFunction2;
    42684252")})));
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r11543 r11546  
    130130    public class Flattener {
    131131        private FClass fc;
    132         private List<FVariable>         globalVariables = new List<FVariable>();
     132        private List<FGlobalVariable>   globalVariables = new List<FGlobalVariable>();
    133133        private List<FVariable>         variables       = new List<FVariable>();
    134134        private List<FAbstractEquation> normalEqns      = new List<FAbstractEquation>();
     
    176176        }
    177177       
    178         public List<FVariable> getGlobalVariables() {
     178        public List<FGlobalVariable> getFGlobalVariables() {
    179179            return globalVariables;
    180180        }
     
    200200        }
    201201       
    202         public List<FVariable> addGlobalVariable(FVariable fvariable) {
     202        public void addGlobalVariable(FVariable fvariable) {
    203203            addFlattened(fvariable.name());
    204             return globalVariables.add(fvariable);
    205         }
    206        
    207         public List<FVariable> addFVariable(FVariable fvariable) {
    208             return variables.add(fvariable);
    209         }
    210        
    211         public List<FAbstractEquation> addNormalEquation(FAbstractEquation fae) {
    212             return normalEqns.add(fae);
    213         }
    214        
    215          public List<FAbstractEquation> addParameterEquation(FAbstractEquation fae) {
    216             return parameterEqns.add(fae);
    217         }
    218        
    219         public List<FFunctionDecl> addFFunctionDecl(FFunctionDecl ffd) {
     204            globalVariables.add((FGlobalVariable)fvariable);
     205        }
     206       
     207        public void addFVariable(FVariable fvariable) {
     208            variables.add(fvariable);
     209        }
     210       
     211        public void addNormalEquation(FAbstractEquation fae) {
     212            normalEqns.add(fae);
     213        }
     214       
     215         public void addParameterEquation(FAbstractEquation fae) {
     216            parameterEqns.add(fae);
     217        }
     218       
     219        public void addFFunctionDecl(FFunctionDecl ffd) {
    220220            addFlattened(ffd.name());
    221             return functionDecls.add(ffd);
    222         }
    223        
    224         public List<FRecordDecl> addFRecordDecl(FRecordDecl frd) {
     221            functionDecls.add(ffd);
     222        }
     223       
     224        public void addFRecordDecl(FRecordDecl frd) {
    225225            addFlattened(frd.name());
    226             return recordDecls.add(frd);
    227         }
    228        
    229         public List<FEnumDecl> addFEnumDecl(FEnumDecl fed) {
     226            recordDecls.add(frd);
     227        }
     228       
     229        public void addFEnumDecl(FEnumDecl fed) {
    230230            addFlattened(fed.name());
    231             return enumDecls.add(fed);
    232         }
    233        
    234         public List<FDerivedType> addFDerivedType(FDerivedType fdt) {
     231            enumDecls.add(fed);
     232        }
     233       
     234        public void addFDerivedType(FDerivedType fdt) {
    235235            addFlattened(fdt.name());
    236             return derivedTypes.add(fdt);
     236            derivedTypes.add(fdt);
    237237        }
    238238
     
    263263    // refined in OptimicaFlattening
    264264    public void FClass.update(Flattener f) {
    265         setGlobalVariableList(f.getGlobalVariables());
     265        setFGlobalVariableList(f.getFGlobalVariables());
    266266        setFVariableList(f.getFVariables());
    267267        setFAbstractEquationList(f.getNormalEquations());
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/TransformCanonical.jrag

    r11543 r11546  
    8888
    8989    public void FClass.transformCanonicalCleanup() {
    90         removeUnusedFunctionsAndRecords();
     90        removeUnusedGlobals();
    9191        root().flushAllRecursive();
    92         for (FRecordDecl rec : getFRecordDecls())
    93             rec.clearBindingEquations();
    9492    }
    9593   
     
    29362934   
    29372935}
    2938 
    2939 aspect FunctionAndRecordCleanup {
    2940     /**
    2941      * Remove unused function and record declarations from the flat model.
    2942      */
    2943     public void FClass.removeUnusedFunctionsAndRecords() {
    2944         beginStep("removeUnusedFunctionsAndRecords()");
    2945         for (FFunctionDecl decl : getFFunctionDecls())
    2946             decl.resetUsedIndicator();
    2947         for (FRecordDecl decl : getFRecordDecls())
    2948             decl.resetUsedIndicator();
    2949         getFVariables().markUsedFunctionsAndRecords();
    2950         getGlobalVariables().markUsedFunctionsAndRecords();
    2951         getFInitialEquations().markUsedFunctionsAndRecords();
    2952         getParameterEquations().markUsedFunctionsAndRecords();
    2953         getFAbstractEquations().markUsedFunctionsAndRecords();
    2954         getDynamicStateManager().markUsedFunctionsAndRecords();
    2955         List<FFunctionDecl> funcs = new List<FFunctionDecl>();
    2956         for (FFunctionDecl func : getFFunctionDecls())
    2957             if (func.functionIsUsed())
    2958                 funcs.add(func);
    2959         setFFunctionDeclList(funcs);
    2960         List<FRecordDecl> records = new List<FRecordDecl>();
    2961         for (FRecordDecl decl : getFRecordDecls())
    2962             if (decl.isRecordUsed())
    2963                 records.add(decl);
    2964         setFRecordDeclList(records);
    2965         endStep("removeUnusedFunctionsAndRecords()");
    2966     }
    2967    
    2968     public class FFunctionDecl {
    2969         public enum UseType{
    2970             NONE(false, false),
    2971             ALIAS_ATTRIBUTE_USE(false, false),
    2972             ANNOTATION_DERIVATIVE(true, false),
    2973             DIRECT(true, true);
    2974            
    2975             private final boolean normalUse;
    2976             private final boolean derivativeUse;
    2977             UseType(boolean normalUse, boolean derivativeUse) {
    2978                 this.normalUse = normalUse;
    2979                 this.derivativeUse = derivativeUse;
    2980             }
    2981             public boolean normalUse() {
    2982                 return normalUse;
    2983             }
    2984             public boolean derivativeUse() {
    2985                 return derivativeUse;
    2986             }
    2987            
    2988             public UseType combine(UseType other) {
    2989                 return compareTo(other) > 0 ? this : other;
    2990             }
    2991         }
    2992     }
    2993    
    2994     private UseType FFunctionDecl.functionUsed = UseType.NONE;
    2995    
    2996     public void FFunctionDecl.resetUsedIndicator() {
    2997         functionUsed = UseType.NONE;
    2998     }
    2999    
    3000     /**
    3001      * Has this function been marked as used?
    3002      */
    3003     syn boolean FFunctionDecl.functionIsUsed() = functionUsed != UseType.NONE;
    3004    
    3005     /**
    3006      * Has this function been marked as used?
    3007      */
    3008     syn boolean FFunctionDecl.functionIsUsedAsDerivative() = functionUsed.derivativeUse();
    3009    
    3010     private boolean FRecordDecl.recordUsed = false;
    3011    
    3012     public void FRecordDecl.resetUsedIndicator() {
    3013         recordUsed = false;
    3014     }
    3015    
    3016     syn boolean FRecordDecl.isRecordUsed() = recordUsed;
    3017    
    3018     /**
    3019      * Mark all called functions as used.
    3020      */
    3021     public final void ASTNode.markUsedFunctionsAndRecords() {
    3022         markUsedFunctionsAndRecords(FFunctionDecl.UseType.DIRECT);
    3023     }
    3024     public void ASTNode.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3025         for (ASTNode node : this)
    3026             node.markUsedFunctionsAndRecords(type);
    3027     }
    3028    
    3029     @Override
    3030     public void FVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3031         AliasManager.AliasSet set = aliasSet();
    3032         if (type != FFunctionDecl.UseType.ALIAS_ATTRIBUTE_USE && set != null)
    3033             for (AliasManager.AliasVariable alias : set)
    3034                 if (alias.getFVariable() != this)
    3035                     alias.getFVariable().markUsedFunctionsAndRecords(FFunctionDecl.UseType.ALIAS_ATTRIBUTE_USE);
    3036         super.markUsedFunctionsAndRecords(type);
    3037     }
    3038    
    3039     public void FExternalObjectVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3040         super.markUsedFunctionsAndRecords(type);
    3041         getDestructorCall().markUsedFunctionsAndRecords(type);
    3042     }
    3043    
    3044     @Override
    3045     public void FFunctionCall.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3046         myFCallable().markUsedFunctionsAndRecords(type);
    3047         super.markUsedFunctionsAndRecords(type);
    3048     }
    3049    
    3050     public interface FCallable {
    3051         public void markUsedFunctionsAndRecords(FFunctionDecl.UseType type);
    3052     }
    3053    
    3054     @Override
    3055     public void FFunctionDecl.markUsedFunctionsAndRecords(UseType type) {
    3056         UseType oldType = functionUsed;
    3057         functionUsed = functionUsed.combine(type);
    3058         if (functionUsed != oldType) {
    3059             markUsedFunctionsAndRecordsExtra(type);
    3060             super.markUsedFunctionsAndRecords(functionUsed);
    3061         }
    3062     }
    3063    
    3064     public void FFunctionDecl.markUsedFunctionsAndRecordsExtra(UseType type) {
    3065         // Hook to facilitate extensions
    3066     }
    3067    
    3068     @Override
    3069     public void FFunctionVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3070         super.markUsedFunctionsAndRecords(type);
    3071         if (type().isFunction()) {
    3072             myFCallable().markUsedFunctionsAndRecords(type);
    3073         }
    3074     }
    3075 
    3076     @Override
    3077     public void FRecordVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3078         super.markUsedFunctionsAndRecords(type);
    3079         myFRecordDecl().markUsedFunctionsAndRecords(type);
    3080     }
    3081 
    3082     @Override
    3083     public void FType.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3084         super.markUsedFunctionsAndRecords(type);
    3085         getSize().markUsedFunctionsAndRecords(type);
    3086     }
    3087    
    3088     public void Size.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3089        
    3090     }
    3091    
    3092     @Override
    3093     public void MutableSize.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3094         for (FExp e : exps)
    3095             if (e != null)
    3096                 e.markUsedFunctionsAndRecords(type);
    3097     }
    3098    
    3099     @Override
    3100     public void FRecordType.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3101         super.markUsedFunctionsAndRecords(type);
    3102         myFRecordDecl().markUsedFunctionsAndRecords(type);
    3103     }
    3104    
    3105     @Override
    3106     public void FRecordConstructor.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3107         super.markUsedFunctionsAndRecords(type);
    3108         getRecord().myFRecordDecl().markUsedFunctionsAndRecords(type);
    3109     }
    3110    
    3111     @Override
    3112     public void FRecordDecl.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3113         if (!recordUsed) {
    3114             recordUsed = true;
    3115             super.markUsedFunctionsAndRecords(type);
    3116         }
    3117     }
    3118    
    3119 }
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/FunctionInlining.mo

    r11543 r11546  
    50205020 constant Real c[2] = 3;
    50215021 Real x;
    5022 package constant
    5023  constant Real FunctionInlining.GlobalConst1.c[2] = {2, 3};
    50245022equation
    50255023 x = 2.0;
     
    50535051 parameter Integer temp_2;
    50545052 parameter Real y.x;
    5055 package constant
    5056  constant FunctionInlining.GlobalConst2.R2 FunctionInlining.GlobalConst2.f.a = FunctionInlining.GlobalConst2.R2({FunctionInlining.GlobalConst2.R1(2), FunctionInlining.GlobalConst2.R1(3)});
    50575053parameter equation
    50585054 temp_2 = integer(time);
    50595055 y.x = ({2, 3})[temp_2];
    5060 
    5061 public
    5062  record FunctionInlining.GlobalConst2.R1
    5063   parameter Real x;
    5064  end FunctionInlining.GlobalConst2.R1;
    5065 
    5066  record FunctionInlining.GlobalConst2.R2
    5067   parameter FunctionInlining.GlobalConst2.R1 r1[2];
    5068  end FunctionInlining.GlobalConst2.R2;
    5069 
    50705056end FunctionInlining.GlobalConst2;
    50715057")})));
Note: See TracChangeset for help on using the changeset viewer.