Changeset 96ac72c


Ignore:
Timestamp:
Jul 24, 2019, 10:42:18 AM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
504eb72
Parents:
4eb43fa (diff), 83b52f1 (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' into new-ast

Files:
1 added
21 edited

Legend:

Unmodified
Added
Removed
  • libcfa/prelude/prelude-gen.cc

    r4eb43fa r96ac72c  
    1 // 
     1//
    22// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
    33//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 // 
    7 // prelude-gen.cc -- 
    8 // 
     6//
     7// prelude-gen.cc --
     8//
    99// Author           : Rob Schluntz and Thierry Delisle
    1010// Created On       : Sat Feb 16 08:44:58 2019
     
    1212// Last Modified On : Tue Apr  2 17:18:24 2019
    1313// Update Count     : 37
    14 // 
     14//
    1515
    1616#include <algorithm>
     
    264264                for (auto cvq : qualifiersPair) {
    265265                        for (auto is_vol : { "        ", "volatile" }) {
    266                                 cout << "forall(dtype DT) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
     266                                cout << "forall(dtype DT) void  ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
    267267                        }
    268268                }
    269                 for (auto cvq : qualifiersSingle) {
    270                         for (auto is_vol : { "        ", "volatile" }) {
    271                                 cout << "forall(dtype DT) void ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
    272                         }
    273                         for (auto is_vol : { "        ", "volatile" }) {
    274                                 cout << "forall(dtype DT) void ^?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
    275                         }
     269        }
     270        for (auto cvq : qualifiersSingle) {
     271                for (auto is_vol : { "        ", "volatile" }) {
     272                        cout << "void  ?{}(" << cvq << "void" << " * " << is_vol << " &);" << endl;
     273                }
     274                for (auto is_vol : { "        ", "volatile" }) {
     275                        cout << "void ^?{}(" << cvq << "void" << " * " << is_vol << " &);" << endl;
     276                }
     277        }
     278
     279        for (auto cvq : qualifiersSingle) {
     280                for (auto is_vol : { "        ", "volatile" }) {
     281                        cout << "forall(dtype DT) void  ?{}(" << cvq << "  DT" << " * " << is_vol << " &);" << endl;
     282                }
     283                for (auto is_vol : { "        ", "volatile" }) {
     284                        cout << "forall(dtype DT) void ^?{}(" << cvq << "  DT" << " * " << is_vol << " &);" << endl;
    276285                }
    277286        }
     
    288297        cout << endl;
    289298
    290         cout << "forall(ftype FT) void  ?{}( FT *          &, zero_t ); " << endl;
     299        cout << "forall(ftype FT) void  ?{}( FT *          &, zero_t );" << endl;
    291300        cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
    292301        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
  • libcfa/src/heap.cfa

    r4eb43fa r96ac72c  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May  9 16:29:12 2019
    13 // Update Count     : 516
     12// Last Modified On : Tue Jul 23 14:13:13 2019
     13// Update Count     : 549
    1414//
    1515
     
    3131
    3232
    33 enum {
    34         __CFA_DEFAULT_MMAP_START__ = (512 * 1024 + 1),
    35         __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
    36 };
    37 
    38 size_t default_mmap_start() __attribute__(( weak )) {
    39         return __CFA_DEFAULT_MMAP_START__;
    40 } // default_mmap_start
    41 
    42 size_t default_heap_expansion() __attribute__(( weak )) {
    43         return __CFA_DEFAULT_HEAP_EXPANSION__;
    44 } // default_heap_expansion
    45 
    46 
    47 // supported mallopt options
    48 #ifndef M_MMAP_THRESHOLD
    49 #define M_MMAP_THRESHOLD (-1)
    50 #endif // M_TOP_PAD
    51 #ifndef M_TOP_PAD
    52 #define M_TOP_PAD (-2)
    53 #endif // M_TOP_PAD
    54 
    55 #define FASTLOOKUP
    56 #define __STATISTICS__
    57 
    58 #define SPINLOCK 0
    59 #define LOCKFREE 1
    60 #define BUCKETLOCK SPINLOCK
    61 #if BUCKETLOCK == LOCKFREE
    62 #include <uStackLF.h>
    63 #endif // LOCKFREE
    64 
    65 // #comment TD : This defined is significantly different from the __ALIGN__ define from locks.hfa
    66 #define ALIGN 16
    67 
    68 // enum { NoBucketSizes = 93,                                                           // number of buckets sizes
    69 // #ifdef FASTLOOKUP
    70 //         LookupSizes = 65536,                                                         // number of fast lookup sizes
    71 // #endif // FASTLOOKUP
    72 // };
    73 #define NoBucketSizes 93                                                                // number of buckets sizes
    74 #ifdef FASTLOOKUP
    75 #define LookupSizes 65536                                                               // number of fast lookup sizes
    76 #endif // FASTLOOKUP
    77 
    78 
    7933static bool traceHeap = false;
    8034
     
    13286//      return temp;
    13387// } // traceHeapTermOff
     88
     89
     90enum {
     91        __CFA_DEFAULT_MMAP_START__ = (512 * 1024 + 1),
     92        __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
     93};
     94
     95size_t default_mmap_start() __attribute__(( weak )) {
     96        return __CFA_DEFAULT_MMAP_START__;
     97} // default_mmap_start
     98
     99size_t default_heap_expansion() __attribute__(( weak )) {
     100        return __CFA_DEFAULT_HEAP_EXPANSION__;
     101} // default_heap_expansion
    134102
    135103
     
    160128#endif // __CFA_DEBUG__
    161129
     130// statically allocated variables => zero filled.
     131static size_t pageSize;                                                                 // architecture pagesize
     132static size_t heapExpand;                                                               // sbrk advance
     133static size_t mmapStart;                                                                // cross over point for mmap
     134static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
     135
     136
     137// #comment TD : This defined is significantly different from the __ALIGN__ define from locks.hfa
     138#define ALIGN 16
     139
     140#define SPINLOCK 0
     141#define LOCKFREE 1
     142#define BUCKETLOCK SPINLOCK
     143#if BUCKETLOCK == LOCKFREE
     144#include <uStackLF.h>
     145#endif // LOCKFREE
     146
     147// Recursive definitions: HeapManager needs size of bucket array and bucket area needs sizeof HeapManager storage.
     148// Break recusion by hardcoding number of buckets and statically checking number is correct after bucket array defined.
     149enum { NoBucketSizes = 93 };                                                    // number of buckets sizes
    162150
    163151struct HeapManager {
     
    234222}; // HeapManager
    235223
    236 
    237224static inline size_t getKey( const HeapManager.FreeHeader & freeheader ) { return freeheader.blockSize; }
    238225
    239 // statically allocated variables => zero filled.
    240 static size_t pageSize;                                                                 // architecture pagesize
    241 static size_t heapExpand;                                                               // sbrk advance
    242 static size_t mmapStart;                                                                // cross over point for mmap
    243 static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
     226
     227#define FASTLOOKUP
     228#define __STATISTICS__
    244229
    245230// Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size.
    246 static const unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes
     231static const unsigned int bucketSizes[] @= {                    // different bucket sizes
    247232        16, 32, 48, 64,
    248233        64 + sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224,
     
    259244        4_194_304 + sizeof(HeapManager.Storage)
    260245};
     246
     247static_assert( NoBucketSizes == sizeof(bucketSizes) / sizeof(bucketSizes[0]), "size of bucket array wrong" );
     248
    261249#ifdef FASTLOOKUP
     250static_assert( 16 == sizeof(HeapManager.Storage), "size of HeapManager Storage wrong" ); // FIX ME
     251enum { LookupSizes = 65_536 + 16 };                                             // number of fast lookup sizes
    262252static unsigned char lookup[LookupSizes];                               // O(1) lookup for small sizes
    263253#endif // FASTLOOKUP
     
    532522
    533523
     524size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
     525        size_t l = 0, m, h = dim;
     526        while ( l < h ) {
     527                m = (l + h) / 2;
     528                if ( (unsigned int &)(vals[m]) < key ) {                // cast away const
     529                        l = m + 1;
     530                } else {
     531                        h = m;
     532                } // if
     533        } // while
     534        return l;
     535} // Bsearchl
     536
     537
    534538static inline void * doMalloc( size_t size ) with ( heapManager ) {
    535539        HeapManager.Storage * block;                                            // pointer to new block of storage
     
    540544        size_t tsize = size + sizeof(HeapManager.Storage);
    541545        if ( likely( tsize < mmapStart ) ) {                            // small size => sbrk
    542                 HeapManager.FreeHeader * freeElem =
    543                         #ifdef FASTLOOKUP
    544                         tsize < LookupSizes ? &freeLists[lookup[tsize]] :
    545                         #endif // FASTLOOKUP
    546                         bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
     546                size_t posn;
     547                #ifdef FASTLOOKUP
     548                if ( tsize < LookupSizes ) posn = lookup[tsize];
     549                else
     550                #endif // FASTLOOKUP
     551                        posn = Bsearchl( (unsigned int)tsize, bucketSizes, (size_t)maxBucketsUsed );
     552                HeapManager.FreeHeader * freeElem = &freeLists[posn];
     553                // #ifdef FASTLOOKUP
     554                // if ( tsize < LookupSizes )
     555                //      freeElem = &freeLists[lookup[tsize]];
     556                // else
     557                // #endif // FASTLOOKUP
     558                //      freeElem = bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
     559                // HeapManager.FreeHeader * freeElem =
     560                //      #ifdef FASTLOOKUP
     561                //      tsize < LookupSizes ? &freeLists[lookup[tsize]] :
     562                //      #endif // FASTLOOKUP
     563                //      bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
    547564                assert( freeElem <= &freeLists[maxBucketsUsed] ); // subscripting error ?
    548565                assert( tsize <= freeElem->blockSize );                 // search failure ?
     
    747764
    748765
     766// supported mallopt options
     767#ifndef M_MMAP_THRESHOLD
     768#define M_MMAP_THRESHOLD (-1)
     769#endif // M_TOP_PAD
     770#ifndef M_TOP_PAD
     771#define M_TOP_PAD (-2)
     772#endif // M_TOP_PAD
     773
     774
    749775extern "C" {
    750776        // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
     
    843869                void * area;
    844870                if ( unlikely( alignment != 0 ) ) {                             // previous request memalign?
    845                         area = memalign( alignment, size );                     // create new area
     871                        area = memalign( alignment, size );                     // create new aligned area
    846872                } else {
    847873                        area = mallocNoStats( size );                           // create new area
  • libcfa/src/stdlib.hfa

    r4eb43fa r96ac72c  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Apr 24 17:35:43 2019
    13 // Update Count     : 352
     12// Last Modified On : Tue Jul 23 14:14:59 2019
     13// Update Count     : 373
    1414//
    1515
     
    1717
    1818#include "bits/defs.hfa"
     19#include "bits/align.hfa"
    1920
    2021#include <stdlib.h>                                                                             // *alloc, strto*, ato*
     22
    2123extern "C" {
    2224        void * memalign( size_t align, size_t size );           // malloc.h
     
    3941
    4042        T * malloc( void ) {
    41                 return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     43                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     44                else return (T *)memalign( _Alignof(T), sizeof(T) );
    4245        } // malloc
    4346
    4447        T * calloc( size_t dim ) {
    45                 return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
     48                if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
     49                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
    4650        } // calloc
    4751
    4852        T * realloc( T * ptr, size_t size ) {
     53                if ( unlikely( ptr == 0 ) ) return malloc();
    4954                return (T *)(void *)realloc( (void *)ptr, size );
    5055        } // realloc
     
    6671
    6772        T * alloc( void ) {
    68                 return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     73                return malloc();
    6974        } // alloc
    7075
    7176        T * alloc( char fill ) {
    72                 T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
     77                T * ptr;
     78                if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     79                else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
    7380                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
    7481        } // alloc
    7582
    7683        T * alloc( size_t dim ) {
    77                 return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
     84                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
     85                else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
    7886        } // alloc
    7987
    8088        T * alloc( size_t dim, char fill ) {
    81                 T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc
    82                 return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value
     89                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
    8390        } // alloc
    8491
    8592        T * alloc( T ptr[], size_t dim ) {
    86                 return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
    87         } // alloc
    88 } // distribution
    89 
    90 
    91 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     93                return realloc( ptr, dim * sizeof(T) );
     94        } // alloc
     95} // distribution
    9296
    9397
     
    107111
    108112        T * align_alloc( size_t align, size_t dim, char fill ) {
    109                 T * ptr;
    110113                if ( fill == '\0' ) {
    111                         ptr = (T *)cmemalign( align, dim, sizeof(T) );
     114                        return (T *)cmemalign( align, dim, sizeof(T) );
    112115                } else {
    113                         ptr = (T *)memalign( align, dim * sizeof(T) );
    114                         return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
     116                        return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
    115117                } // if
    116                 return ptr;
    117         } // align_alloc
    118 } // distribution
     118        } // align_alloc
     119} // distribution
     120
     121forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    119122
    120123
  • src/InitTweak/InitTweak.cc

    r4eb43fa r96ac72c  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 10 13:30:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jun 19 14:34:00 2019
     13// Update Count     : 6
    1414//
    1515
     
    633633                        return nullptr;
    634634                }
     635
     636                DeclarationWithType * getFunctionCore( const Expression * expr ) {
     637                        if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
     638                                return getCalledFunction( appExpr->function );
     639                        } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
     640                                return getCalledFunction( untyped->function );
     641                        }
     642                        assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
     643                }
    635644        }
    636645
    637646        DeclarationWithType * getFunction( Expression * expr ) {
    638                 if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
    639                         return getCalledFunction( appExpr->get_function() );
    640                 } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
    641                         return getCalledFunction( untyped->get_function() );
    642                 }
    643                 assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
     647                return getFunctionCore( expr );
     648        }
     649
     650        const DeclarationWithType * getFunction( const Expression * expr ) {
     651                return getFunctionCore( expr );
    644652        }
    645653
  • src/InitTweak/InitTweak.h

    r4eb43fa r96ac72c  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 10 13:30:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 14:18:00 2019
     13// Update Count     : 6
    1414//
    1515
     
    6161        /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
    6262        DeclarationWithType * getFunction( Expression * expr );
     63        const DeclarationWithType * getFunction( const Expression * expr );
    6364        const ast::DeclWithType * getFunction( const ast::Expr * expr );
    6465
  • src/ResolvExpr/Alternative.h

    r4eb43fa r96ac72c  
    2929        /// One assertion to resolve
    3030        struct AssertionItem {
    31                 DeclarationWithType* decl;
     31                const DeclarationWithType* decl;
    3232                AssertionSetValue info;
    33                
     33
    3434                AssertionItem() = default;
    35                 AssertionItem( DeclarationWithType* decl, const AssertionSetValue& info )
     35                AssertionItem( const DeclarationWithType* decl, const AssertionSetValue& info )
    3636                : decl(decl), info(info) {}
    3737                AssertionItem( const AssertionSet::value_type& e ) : decl(e.first), info(e.second) {}
  • src/ResolvExpr/FindOpenVars.cc

    r4eb43fa r96ac72c  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 09:42:48 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 09:45:25 2015
    13 // Update Count     : 3
     11// Last Modified By : Andrew
     12// Last Modified On : Fri Jul 12 14:18:00 2019
     13// Update Count     : 4
    1414//
    1515
     
    2929                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
    3030
    31                 void previsit( PointerType * pointerType );
    32                 void previsit( ArrayType * arrayType );
    33                 void previsit( FunctionType * functionType );
    34                 void previsit( TupleType * tupleType );
     31                void previsit( const PointerType * pointerType );
     32                void previsit( const ArrayType * arrayType );
     33                void previsit( const FunctionType * functionType );
     34                void previsit( const TupleType * tupleType );
    3535
    36                 void common_action( Type *type );
     36                void common_action( const Type *type );
    3737
    3838                OpenVarSet &openVars, &closedVars;
     
    4141        };
    4242
    43         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
     43        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
    4444                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
    4545                type->accept( finder );
     
    5050        }
    5151
    52         void FindOpenVars_old::common_action( Type *type ) {
     52        void FindOpenVars_old::common_action( const Type * type ) {
    5353                if ( nextIsOpen ) {
    54                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     54                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
    5555                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
    5656                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
     
    6161                        }
    6262                } else {
    63                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     63                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
    6464                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
    6565                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
     
    7878        }
    7979
    80         void FindOpenVars_old::previsit(PointerType *pointerType) {
     80        void FindOpenVars_old::previsit(const PointerType * pointerType) {
    8181                common_action( pointerType );
    8282        }
    8383
    84         void FindOpenVars_old::previsit(ArrayType *arrayType) {
     84        void FindOpenVars_old::previsit(const ArrayType * arrayType) {
    8585                common_action( arrayType );
    8686        }
    8787
    88         void FindOpenVars_old::previsit(FunctionType *functionType) {
     88        void FindOpenVars_old::previsit(const FunctionType * functionType) {
    8989                common_action( functionType );
    9090                nextIsOpen = ! nextIsOpen;
     
    9292        }
    9393
    94         void FindOpenVars_old::previsit(TupleType *tupleType) {
     94        void FindOpenVars_old::previsit(const TupleType * tupleType) {
    9595                common_action( tupleType );
    9696        }
     
    104104                        bool nextIsOpen;
    105105
    106                         FindOpenVars_new( 
    107                                 ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n, 
     106                        FindOpenVars_new(
     107                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
    108108                                ast::AssertionSet & h, FirstMode firstIsOpen )
    109109                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
     
    135135        }
    136136
    137         void findOpenVars( 
    138                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
     137        void findOpenVars(
     138                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
    139139                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
    140140                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
  • src/ResolvExpr/FindOpenVars.h

    r4eb43fa r96ac72c  
    2626namespace ResolvExpr {
    2727        // Updates open and closed variables and their associated assertions
    28         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
     28        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
    2929
    3030        enum FirstMode { FirstClosed, FirstOpen };
  • src/ResolvExpr/Occurs.cc

    r4eb43fa r96ac72c  
    2424        struct Occurs : public WithVisitorRef<Occurs> {
    2525                Occurs( std::string varName, const TypeEnvironment &env );
    26                 void previsit( TypeInstType * typeInst );
     26                void previsit( const TypeInstType * typeInst );
    2727
    2828                bool result;
     
    3131        };
    3232
    33         bool occurs( Type *type, std::string varName, const TypeEnvironment &env ) {
     33        bool occurs( const Type *type, const std::string & varName, const TypeEnvironment &env ) {
    3434                PassVisitor<Occurs> occur( varName, env );
    3535                type->accept( occur );
     
    4545        }
    4646
    47         void Occurs::previsit( TypeInstType * typeInst ) {
     47        void Occurs::previsit( const TypeInstType * typeInst ) {
    4848                ///   std::cerr << "searching for vars: ";
    4949///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
  • src/ResolvExpr/ResolveAssertions.cc

    r4eb43fa r96ac72c  
    7373                CandidateList matches;
    7474
    75                 DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
     75                DeferItem( const DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
    7676                : decl(decl), info(info), matches(std::move(matches)) {}
    7777
  • src/ResolvExpr/TypeEnvironment.cc

    r4eb43fa r96ac72c  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:19:47 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 18 11:58:00 2018
    13 // Update Count     : 4
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jun 18 14:27:00 2019
     13// Update Count     : 5
    1414//
    1515
     
    315315        }
    316316
    317         bool isFtype( Type *type ) {
    318                 if ( dynamic_cast< FunctionType* >( type ) ) {
     317        bool isFtype( const Type * type ) {
     318                if ( dynamic_cast< const FunctionType * >( type ) ) {
    319319                        return true;
    320                 } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
     320                } else if ( const TypeInstType *typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
    321321                        return typeInst->get_isFtype();
    322322                } // if
     
    324324        }
    325325
    326         bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
     326        bool tyVarCompatible( const TypeDecl::Data & data, const Type * type ) {
    327327                switch ( data.kind ) {
    328328                  case TypeDecl::Dtype:
     
    336336                  case TypeDecl::Ttype:
    337337                        // ttype unifies with any tuple type
    338                         return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
     338                        return dynamic_cast< const TupleType * >( type ) || Tuples::isTtype( type );
    339339                  default:
    340340                        assertf(false, "Unhandled tyvar kind: %d", data.kind);
     
    343343        }
    344344
    345         bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
     345        bool TypeEnvironment::bindVar( const TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
    346346
    347347                // remove references from other, so that type variables can only bind to value types
     
    361361                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    362362                                std::unique_ptr< Type > newType( curClass->type->clone() );
    363                                 newType->get_qualifiers() = typeInst->get_qualifiers();
     363                                newType->tq = typeInst->tq;
    364364                                if ( unifyInexact( newType.get(), bindTo, *this, need, have, openVars, widen & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
    365365                                        if ( common ) {
     
    386386        }
    387387
    388         bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2,
    389                         TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, 
     388        bool TypeEnvironment::bindVarToVar( const TypeInstType * var1, const TypeInstType * var2,
     389                        TypeDecl::Data && data, AssertionSet &need, AssertionSet &have,
    390390                        const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
    391391
  • src/ResolvExpr/TypeEnvironment.h

    r4eb43fa r96ac72c  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:24:58 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 30 23:04:10 2019
    13 // Update Count     : 9
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 17:00:10 2019
     13// Update Count     : 10
    1414//
    1515
     
    4040        // declarations.
    4141        //
    42         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this 
     42        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this
    4343        // comparator.
    4444        //
     
    4646        // memory layout can alter compilation time in unpredictable ways. For example, the placement
    4747        // of a line directive can reorder type pointers with respect to each other so that assertions
    48         // are seen in different orders, causing a potentially different number of unification calls 
    49         // when resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering 
    50         // line directives alone, so it would be nice to fix this comparison so that assertions compare 
    51         // more consistently. I've tried to modify this to compare on mangle name instead of type as 
    52         // the second comparator, but this causes some assertions to never be recorded. More 
     48        // are seen in different orders, causing a potentially different number of unification calls
     49        // when resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering
     50        // line directives alone, so it would be nice to fix this comparison so that assertions compare
     51        // more consistently. I've tried to modify this to compare on mangle name instead of type as
     52        // the second comparator, but this causes some assertions to never be recorded. More
    5353        // investigation is needed.
    5454        struct AssertCompare {
    55                 bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
     55                bool operator()( const DeclarationWithType * d1, const DeclarationWithType * d2 ) const {
    5656                        int cmp = d1->get_name().compare( d2->get_name() );
    5757                        return cmp < 0 ||
     
    6565                AssertionSetValue() : isUsed(false), resnSlot(0) {}
    6666        };
    67         typedef std::map< DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
     67        typedef std::map< const DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
    6868        typedef std::unordered_map< std::string, TypeDecl::Data > OpenVarSet;
    6969
     
    7878        struct EqvClass {
    7979                std::set< std::string > vars;
    80                 Type *type;
     80                Type * type;
    8181                bool allowWidening;
    8282                TypeDecl::Data data;
     
    111111                bool isEmpty() const { return env.empty(); }
    112112                void print( std::ostream &os, Indenter indent = {} ) const;
    113                
     113
    114114                /// Simply concatenate the second environment onto this one; no safety checks performed
    115115                void simpleCombine( const TypeEnvironment &second );
     
    126126                /// Returns false if fails, but does NOT roll back partial changes.
    127127                bool combine( const TypeEnvironment& second, OpenVarSet& openVars, const SymTab::Indexer& indexer );
    128                
     128
    129129                void extractOpenVars( OpenVarSet &openVars ) const;
    130130                TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
     
    134134                void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
    135135
    136                 /// Binds the type class represented by `typeInst` to the type `bindTo`; will add 
     136                /// Binds the type class represented by `typeInst` to the type `bindTo`; will add
    137137                /// the class if needed. Returns false on failure.
    138                 bool bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    139                
    140                 /// Binds the type classes represented by `var1` and `var2` together; will add 
     138                bool bindVar( const TypeInstType * typeInst, Type * bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
     139
     140                /// Binds the type classes represented by `var1` and `var2` together; will add
    141141                /// one or both classes if needed. Returns false on failure.
    142                 bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
     142                bool bindVarToVar( const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    143143
    144144                /// Disallows widening for all bindings in the environment
     
    151151          private:
    152152                ClassList env;
    153                
     153
    154154                ClassList::iterator internal_lookup( const std::string &var );
    155155        };
  • src/ResolvExpr/typeops.h

    r4eb43fa r96ac72c  
    149149
    150150        // in Occurs.cc
    151         bool occurs( Type * type, std::string varName, const TypeEnvironment & env );
     151        bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
    152152        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
    153153
     
    200200
    201201        // in TypeEnvironment.cc
    202         bool isFtype( Type * type );
     202        bool isFtype( const Type * type );
    203203} // namespace ResolvExpr
    204204
  • src/SynTree/Type.cc

    r4eb43fa r96ac72c  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 31 21:54:16 2019
    13 // Update Count     : 43
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 12 15:48:00 2019
     13// Update Count     : 44
    1414//
    1515#include "Type.h"
     
    141141}
    142142
     143const Type * Type::stripReferences() const {
     144        const Type * type;
     145        const ReferenceType * ref;
     146        for ( type = this; (ref = dynamic_cast<const ReferenceType *>( type )); type = ref->base );
     147        return type;
     148}
     149
    143150int Type::referenceDepth() const { return 0; }
    144151
  • src/SynTree/Type.h

    r4eb43fa r96ac72c  
    172172        /// return type without outer references
    173173        Type * stripReferences();
     174        const Type * stripReferences() const;
    174175
    175176        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
     
    256257        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    257258
    258         Kind get_kind() { return kind; }
     259        Kind get_kind() const { return kind; }
    259260        void set_kind( Kind newValue ) { kind = newValue; }
    260261
  • src/Tuples/TupleExpansion.cc

    r4eb43fa r96ac72c  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:14:12 2019
    13 // Update Count     : 21
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 14:39:00 2019
     13// Update Count     : 22
    1414//
    1515
     
    350350        }
    351351
     352        const TypeInstType * isTtype( const Type * type ) {
     353                if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type ) ) {
     354                        if ( inst->baseType && inst->baseType->kind == TypeDecl::Ttype ) {
     355                                return inst;
     356                        }
     357                }
     358                return nullptr;
     359        }
     360
    352361        const ast::TypeInstType * isTtype( const ast::Type * type ) {
    353362                if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
     
    364373                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
    365374
    366                         void previsit( ApplicationExpr * appExpr ) {
     375                        void previsit( const ApplicationExpr * appExpr ) {
    367376                                visit_children = false;
    368                                 if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
    369                                         if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
    370                                                 if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
     377                                if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
     378                                        if ( function->linkage == LinkageSpec::Intrinsic ) {
     379                                                if ( function->name == "*?" || function->name == "?[?]" ) {
    371380                                                        // intrinsic dereference, subscript are pure, but need to recursively look for impurity
    372381                                                        visit_children = true;
     
    377386                                maybeImpure = true;
    378387                        }
    379                         void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
    380                         void previsit( UniqueExpr * ) {
     388                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
     389                        void previsit( const UniqueExpr * ) {
    381390                                if ( ignoreUnique ) {
    382391                                        // bottom out at unique expression.
     
    393402        } // namespace
    394403
    395         bool maybeImpure( Expression * expr ) {
     404        bool maybeImpure( const Expression * expr ) {
    396405                PassVisitor<ImpurityDetector> detector( false );
    397406                expr->accept( detector );
     
    399408        }
    400409
    401         bool maybeImpureIgnoreUnique( Expression * expr ) {
     410        bool maybeImpureIgnoreUnique( const Expression * expr ) {
    402411                PassVisitor<ImpurityDetector> detector( true );
    403412                expr->accept( detector );
  • src/Tuples/Tuples.h

    r4eb43fa r96ac72c  
    5252        /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
    5353        TypeInstType * isTtype( Type * type );
     54        const TypeInstType * isTtype( const Type * type );
    5455        const ast::TypeInstType * isTtype( const ast::Type * type );
    5556
    5657        /// returns true if the expression may contain side-effects.
    57         bool maybeImpure( Expression * expr );
     58        bool maybeImpure( const Expression * expr );
    5859        bool maybeImpure( const ast::Expr * expr );
    5960
    6061        /// Returns true if the expression may contain side-effect,
    6162        /// ignoring the presence of unique expressions.
    62         bool maybeImpureIgnoreUnique( Expression * expr );
     63        bool maybeImpureIgnoreUnique( const Expression * expr );
    6364        bool maybeImpureIgnoreUnique( const ast::Expr * expr );
    6465} // namespace Tuples
  • tests/.expect/copyfile.txt

    r4eb43fa r96ac72c  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 16 16:48:16 2019
    13 // Update Count     : 1
     12// Last Modified On : Wed Jul 17 18:04:44 2019
     13// Update Count     : 26
    1414//
    1515
    1616#include <fstream.hfa>
     17#include <stdlib.hfa>                                                                   // new/delete
    1718
    1819int main( int argc, char * argv[] ) {
    19     ifstream & in  = stdin;                             // default files
    20     ofstream & out = stdout;
    21     try {
    22         choose ( argc ) {
    23           case 2, 3:
    24             open( in, argv[1] );                        // open input file first as output creates file
    25             if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
    26           case 1: ;                                     // use default files
    27           default:
    28             exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    29         } // choose
     20        ifstream * in  = &stdin;                                                        // default files
     21        ofstream * out = &stdout;
     22        try {
     23                choose ( argc ) {
     24                  case 2, 3:
     25                          in = new( (const char *)argv[1] );            // open input file first as output creates file
     26                          if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
     27                  case 1: ;                                     // use default files
     28                  default:
     29                          exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     30                } // choose
    3031
    31         char ch;
    32         out | nlOff;                                    // turn off auto newline
    33         in  | nlOn;                                     // turn on reading newline
     32                char ch;
     33                *out | nlOff;                                                                   // turn off auto newline
     34                *in  | nlOn;                                                                    // turn on reading newline
    3435
    35         for () {                                        // read all characters
    36             in | ch;
    37           if ( eof( in ) ) break;                       // eof ?
    38             out | ch;
    39         } // for
    40     } finally {
    41         close( in );                                    // stdin, stdout are never closed
    42         close( out );
    43     } // try
     36                for () {                                                                                // read all characters
     37                        *in | ch;
     38                  if ( eof( *in ) ) break;                                              // eof ?
     39                        *out | ch;
     40                } // for
     41        } finally {
     42                if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
     43                if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
     44        } // try
    4445} // main
    4546
  • tests/.in/copyfile.txt

    r4eb43fa r96ac72c  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 16 16:48:16 2019
    13 // Update Count     : 1
     12// Last Modified On : Wed Jul 17 18:04:44 2019
     13// Update Count     : 26
    1414//
    1515
    1616#include <fstream.hfa>
     17#include <stdlib.hfa>                                                                   // new/delete
    1718
    1819int main( int argc, char * argv[] ) {
    19     ifstream & in  = stdin;                             // default files
    20     ofstream & out = stdout;
    21     try {
    22         choose ( argc ) {
    23           case 2, 3:
    24             open( in, argv[1] );                        // open input file first as output creates file
    25             if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
    26           case 1: ;                                     // use default files
    27           default:
    28             exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    29         } // choose
     20        ifstream * in  = &stdin;                                                        // default files
     21        ofstream * out = &stdout;
     22        try {
     23                choose ( argc ) {
     24                  case 2, 3:
     25                          in = new( (const char *)argv[1] );            // open input file first as output creates file
     26                          if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
     27                  case 1: ;                                     // use default files
     28                  default:
     29                          exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     30                } // choose
    3031
    31         char ch;
    32         out | nlOff;                                    // turn off auto newline
    33         in  | nlOn;                                     // turn on reading newline
     32                char ch;
     33                *out | nlOff;                                                                   // turn off auto newline
     34                *in  | nlOn;                                                                    // turn on reading newline
    3435
    35         for () {                                        // read all characters
    36             in | ch;
    37           if ( eof( in ) ) break;                       // eof ?
    38             out | ch;
    39         } // for
    40     } finally {
    41         close( in );                                    // stdin, stdout are never closed
    42         close( out );
    43     } // try
     36                for () {                                                                                // read all characters
     37                        *in | ch;
     38                  if ( eof( *in ) ) break;                                              // eof ?
     39                        *out | ch;
     40                } // for
     41        } finally {
     42                if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
     43                if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
     44        } // try
    4445} // main
    4546
  • tests/copyfile.cfa

    r4eb43fa r96ac72c  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 16 16:48:16 2019
    13 // Update Count     : 1
     12// Last Modified On : Wed Jul 17 18:04:44 2019
     13// Update Count     : 26
    1414//
    1515
    1616#include <fstream.hfa>
     17#include <stdlib.hfa>                                                                   // new/delete
    1718
    1819int main( int argc, char * argv[] ) {
    19     ifstream & in  = stdin;                             // default files
    20     ofstream & out = stdout;
    21     try {
    22         choose ( argc ) {
    23           case 2, 3:
    24             open( in, argv[1] );                        // open input file first as output creates file
    25             if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
    26           case 1: ;                                     // use default files
    27           default:
    28             exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    29         } // choose
     20        ifstream * in  = &stdin;                                                        // default files
     21        ofstream * out = &stdout;
     22        try {
     23                choose ( argc ) {
     24                  case 2, 3:
     25                          in = new( (const char *)argv[1] );            // open input file first as output creates file
     26                          if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
     27                  case 1: ;                                     // use default files
     28                  default:
     29                          exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     30                } // choose
    3031
    31         char ch;
    32         out | nlOff;                                    // turn off auto newline
    33         in  | nlOn;                                     // turn on reading newline
     32                char ch;
     33                *out | nlOff;                                                                   // turn off auto newline
     34                *in  | nlOn;                                                                    // turn on reading newline
    3435
    35         for () {                                        // read all characters
    36             in | ch;
    37           if ( eof( in ) ) break;                       // eof ?
    38             out | ch;
    39         } // for
    40     } finally {
    41         close( in );                                    // stdin, stdout are never closed
    42         close( out );
    43     } // try
     36                for () {                                                                                // read all characters
     37                        *in | ch;
     38                  if ( eof( *in ) ) break;                                              // eof ?
     39                        *out | ch;
     40                } // for
     41        } finally {
     42                if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
     43                if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
     44        } // try
    4445} // main
    4546
  • tests/heap.cfa

    r4eb43fa r96ac72c  
    1010// Created On       : Tue Nov  6 17:54:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec 11 21:52:40 2018
    13 // Update Count     : 18
     12// Last Modified On : Fri Jul 19 08:22:34 2019
     13// Update Count     : 19
    1414//
    1515
     
    2929#define __U_DEFAULT_MMAP_START__ (512 * 1024 + 1)
    3030size_t default_mmap_start() __attribute__(( weak )) {
    31     return __U_DEFAULT_MMAP_START__;
     31        return __U_DEFAULT_MMAP_START__;
    3232} // default_mmap_start
    3333
     
    3636
    3737void main( Worker & ) {
    38     enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
    39     char * locns[NoOfAllocs];
    40     int i;
    41 
    42     // check alloc/free
    43 
    44     for ( j; 40 ) {
     38        enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
     39        char * locns[NoOfAllocs];
     40        int i;
     41
     42        // check alloc/free
     43
     44        for ( j; 40 ) {
    4545                for ( i; NoOfAllocs ) {
    4646                        locns[i] = alloc( i );
     
    6767                        free( locns[i] );
    6868                } // for
    69     } // for
    70 
    71     // check malloc/free (sbrk)
    72 
    73     for ( i; NoOfAllocs ) {
     69        } // for
     70
     71        // check malloc/free (sbrk)
     72
     73        for ( i; NoOfAllocs ) {
    7474                size_t s = (i + 1) * 20;
    7575                char * area = (char *)malloc( s );
     
    7878                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    7979                free( area );
    80     } // for
    81 
    82     for ( i; NoOfAllocs ) {
     80        } // for
     81
     82        for ( i; NoOfAllocs ) {
    8383                size_t s = i + 1;                                                               // +1 to make initialization simpler
    8484                locns[i] = (char *)malloc( s );
     
    8686                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    8787                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    88     } // for
    89     for ( i; NoOfAllocs ) {
     88        } // for
     89        for ( i; NoOfAllocs ) {
    9090                size_t s = i + 1;
    9191                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    9292                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
    9393                free( locns[i] );
    94     } // for
    95 
    96     // check malloc/free (mmap)
    97 
    98     for ( i; NoOfMmaps ) {
     94        } // for
     95
     96        // check malloc/free (mmap)
     97
     98        for ( i; NoOfMmaps ) {
    9999                size_t s = i + default_mmap_start();                    // cross over point
    100100                char * area = (char *)malloc( s );
     
    103103                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    104104                free( area );
    105     } // for
    106 
    107     for ( i; NoOfMmaps ) {
     105        } // for
     106
     107        for ( i; NoOfMmaps ) {
    108108                size_t s = i + default_mmap_start();                    // cross over point
    109109                locns[i] = (char *)malloc( s );
     
    111111                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    112112                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    113     } // for
    114     for ( i; NoOfMmaps ) {
     113        } // for
     114        for ( i; NoOfMmaps ) {
    115115                size_t s = i + default_mmap_start();                    // cross over point
    116116                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    117117                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
    118118                free( locns[i] );
    119     } // for
    120 
    121     // check calloc/free (sbrk)
    122 
    123     for ( i; NoOfAllocs ) {
     119        } // for
     120
     121        // check calloc/free (sbrk)
     122
     123        for ( i; NoOfAllocs ) {
    124124                size_t s = (i + 1) * 20;
    125125                char * area = (char *)calloc( 5, s );
     
    131131                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    132132                free( area );
    133     } // for
    134 
    135     for ( i; NoOfAllocs ) {
     133        } // for
     134
     135        for ( i; NoOfAllocs ) {
    136136                size_t s = i + 1;
    137137                locns[i] = (char *)calloc( 5, s );
     
    142142                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    143143                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    144     } // for
    145     for ( i; NoOfAllocs ) {
     144        } // for
     145        for ( i; NoOfAllocs ) {
    146146                size_t s = i + 1;
    147147                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    148148                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage3" );
    149149                free( locns[i] );
    150     } // for
    151 
    152     // check calloc/free (mmap)
    153 
    154     for ( i; NoOfMmaps ) {
     150        } // for
     151
     152        // check calloc/free (mmap)
     153
     154        for ( i; NoOfMmaps ) {
    155155                size_t s = i + default_mmap_start();                    // cross over point
    156156                char * area = (char *)calloc( 1, s );
     
    162162                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    163163                free( area );
    164     } // for
    165 
    166     for ( i; NoOfMmaps ) {
     164        } // for
     165
     166        for ( i; NoOfMmaps ) {
    167167                size_t s = i + default_mmap_start();                    // cross over point
    168168                locns[i] = (char *)calloc( 1, s );
     
    173173                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    174174                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    175     } // for
    176     for ( i; NoOfMmaps ) {
     175        } // for
     176        for ( i; NoOfMmaps ) {
    177177                size_t s = i + default_mmap_start();                    // cross over point
    178178                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    179179                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage6" );
    180180                free( locns[i] );
    181     } // for
    182 
    183     // check memalign/free (sbrk)
    184 
    185     enum { limit = 64 * 1024 };                                                 // check alignments up to here
     181        } // for
     182
     183        // check memalign/free (sbrk)
     184
     185        enum { limit = 64 * 1024 };                                                     // check alignments up to here
    186186
    187187        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
     
    198198                        free( area );
    199199                } // for
    200     } // for
    201 
    202     // check memalign/free (mmap)
     200        } // for
     201
     202        // check memalign/free (mmap)
    203203
    204204        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
     
    216216                        free( area );
    217217                } // for
    218     } // for
    219 
    220     // check calloc/realloc/free (sbrk)
    221 
    222     for ( i; 1 ~ 10_000 ~ 12 ) {
     218        } // for
     219
     220        // check calloc/realloc/free (sbrk)
     221
     222        for ( i; 1 ~ 10_000 ~ 12 ) {
    223223                // initial N byte allocation
    224224                char * area = (char *)calloc( 5, i );
     
    237237                } // for
    238238                free( area );
    239     } // for
    240 
    241     // check calloc/realloc/free (mmap)
    242 
    243     for ( i; 1 ~ 10_000 ~ 12 ) {
     239        } // for
     240
     241        // check calloc/realloc/free (mmap)
     242
     243        for ( i; 1 ~ 10_000 ~ 12 ) {
    244244                // initial N byte allocation
    245245                size_t s = i + default_mmap_start();                    // cross over point
     
    259259                } // for
    260260                free( area );
    261     } // for
    262 
    263     // check memalign/realloc/free
    264 
    265     size_t amount = 2;
     261        } // for
     262
     263        // check memalign/realloc/free
     264
     265        size_t amount = 2;
    266266        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    267267                // initial N byte allocation
     
    286286                } // for
    287287                free( area );
    288     } // for
    289 
    290     // check cmemalign/free
     288        } // for
     289
     290        // check cmemalign/free
    291291
    292292        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
     
    305305                        free( area );
    306306                } // for
    307     } // for
    308 
    309     // check cmemalign/realloc/free
    310 
    311     amount = 2;
     307        } // for
     308
     309        // check cmemalign/realloc/free
     310
     311        amount = 2;
    312312        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    313313                // initial N byte allocation
     
    338338                } // for
    339339                free( area );
    340     } // for
     340        } // for
    341341        //sout | "worker" | thisTask() | "successful completion";
    342342} // Worker main
    343343
    344344int main() {
    345     const unsigned int NoOfWorkers = 4;
    346     {
     345        const unsigned int NoOfWorkers = 4;
     346        {
    347347                processor processors[NoOfWorkers - 1] __attribute__(( unused )); // more than one processor
    348348                Worker workers[NoOfWorkers] __attribute__(( unused ));
    349     }
     349        }
    350350        // checkFreeOn();
    351     // malloc_stats();
     351        // malloc_stats();
    352352}
    353353
Note: See TracChangeset for help on using the changeset viewer.