Index: Jenkinsfile =================================================================== --- Jenkinsfile (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ Jenkinsfile (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -31,12 +31,10 @@ //Run the tests from the tests directory - dir ('src/tests') { - if (full_build) { - sh 'make all-tests debug=yes' - sh 'make all-tests debug=no' - } - else { - sh 'make' - } + if (full_build) { + sh 'make -C src/tests all-tests debug=yes' + sh 'make -C src/tests all-tests debug=no' + } + else { + sh 'make -C src/tests' } Index: configure =================================================================== --- configure (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ configure (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -6184,5 +6184,5 @@ -ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/examples/Makefile src/tests/Makefile src/prelude/Makefile src/libcfa/Makefile" +ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/benchmark/Makefile src/examples/Makefile src/tests/Makefile src/prelude/Makefile src/libcfa/Makefile" @@ -6945,4 +6945,5 @@ "src/driver/Makefile") CONFIG_FILES="$CONFIG_FILES src/driver/Makefile" ;; "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; + "src/benchmark/Makefile") CONFIG_FILES="$CONFIG_FILES src/benchmark/Makefile" ;; "src/examples/Makefile") CONFIG_FILES="$CONFIG_FILES src/examples/Makefile" ;; "src/tests/Makefile") CONFIG_FILES="$CONFIG_FILES src/tests/Makefile" ;; Index: configure.ac =================================================================== --- configure.ac (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ configure.ac (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -190,4 +190,5 @@ src/driver/Makefile src/Makefile + src/benchmark/Makefile src/examples/Makefile src/tests/Makefile Index: src/CodeTools/DeclStats.cc =================================================================== --- src/CodeTools/DeclStats.cc (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/CodeTools/DeclStats.cc (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,302 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// DeclStats.cc -- +// +// Author : Aaron Moss +// Created On : Wed Jan 31 16:40:00 2016 +// Last Modified By : Aaron Moss +// Last Modified On : Wed Jan 31 16:40:00 2016 +// Update Count : 1 +// + +#include "DeclStats.h" + +#include +#include +#include +#include +#include + +#include "Common/VectorMap.h" +#include "GenPoly/GenPoly.h" +#include "Parser/LinkageSpec.h" +#include "SynTree/Declaration.h" +#include "SynTree/Visitor.h" + +namespace CodeTools { + + class DeclStats : public Visitor { + struct Stats { + unsigned n_decls; ///< Total number of declarations + /// Count of declarations with each number of assertion parameters + VectorMap n_type_params; + /// Count of declarations with each name + std::unordered_map by_name; + + /// Count of declarations with each number of parameters + VectorMap n_params; + /// Count of declarations with each number of return types + VectorMap n_returns; + /// Count of declarations with each number of polymorphic parameters + VectorMap n_poly_params; + /// Count of declarations with each number of polymorphic return types + VectorMap n_poly_returns; + /// Count of declarations with each percentage of polymorphic parameters + std::map p_poly_params; + /// Count of declarations with each percentage of polymorphic returns + std::map p_poly_returns; + + /// Count of declarations with each number of assertions + std::map n_assertions; + /// Count of assertions with each number of parameters + VectorMap n_assn_params; + /// Count of assertions with each number of return types + VectorMap n_assn_returns; + /// Count of assertions with each number of polymorphic parameters + VectorMap n_assn_poly_params; + /// Count of assertions with each number of polymorphic return types + VectorMap n_assn_poly_returns; + /// Count of assertions with each percentage of polymorphic parameters + std::map p_assn_poly_params; + /// Count of assertions with each percentage of polymorphic returns + std::map p_assn_poly_returns; + + Stats() + : n_decls(0), n_type_params(), by_name(), + n_params(), n_returns(), n_poly_params(), n_poly_returns(), p_poly_params(), p_poly_returns(), + n_assertions(), n_assn_params(), n_assn_returns(), n_assn_poly_params(), n_assn_poly_returns(), p_assn_poly_params(), p_assn_poly_returns() {} + + private: + template + static void sum(T& a, const T& b) { a += b; } + + static void sum(VectorMap& a, const VectorMap& b) { + a.reserve( b.size() ); + for ( unsigned i = 0; i < b.size(); ++i ) { + a[i] += b[i]; + } + } + + template + static void sum(std::map& a, const std::map& b) { + for ( const auto& entry : b ) { + a[ entry.first ] += entry.second; + } + } + + template + static void sum(std::unordered_map& a, const std::unordered_map& b) { + for ( const auto& entry : b ) { + a[ entry.first ] += entry.second; + } + } + + public: + Stats& operator+= (const Stats& o) { + sum( n_decls, o.n_decls ); + sum( n_type_params, o.n_type_params ); + sum( by_name, o.by_name ); + + sum( n_params, o.n_params ); + sum( n_returns, o.n_returns ); + sum( n_poly_params, o.n_poly_params ); + sum( n_poly_returns, o.n_poly_returns ); + sum( p_poly_params, o.p_poly_params ); + sum( p_poly_returns, o.p_poly_returns ); + + sum( n_assertions, o.n_assertions ); + sum( n_assn_params, o.n_assn_params ); + sum( n_assn_returns, o.n_assn_returns ); + sum( n_assn_poly_params, o.n_assn_poly_params ); + sum( n_assn_poly_returns, o.n_assn_poly_returns ); + sum( p_assn_poly_params, o.p_assn_poly_params ); + sum( p_assn_poly_returns, o.p_assn_poly_returns ); + + return *this; + } + }; + + Stats for_linkage[LinkageSpec::NoOfSpecs]; ///< Stores separate stats per linkage + std::unordered_set seen_names; ///< Stores manglenames already seen to avoid double-counting + Stats total; + + void analyzeFunc( FunctionType* fnTy, VectorMap& by_params, VectorMap& by_poly_params, + VectorMap& by_returns, VectorMap& by_poly_returns, + std::map& p_poly_params, std::map& p_poly_returns ) { + unsigned n_params = 0; + unsigned n_poly_params = 0; + for ( auto pdecl : fnTy->get_parameters() ) { + n_params += pdecl->get_type()->size(); + if ( GenPoly::hasPolyBase( pdecl->get_type() ) ) ++n_poly_params; + } + ++by_params.at( n_params ); + ++by_poly_params.at( n_poly_params ); + if ( n_params > 0 ) ++p_poly_params[ n_poly_params*100/n_params ]; + + unsigned n_returns = 0; + unsigned n_poly_returns = 0; + for ( auto rdecl : fnTy->get_returnVals() ) { + n_returns += rdecl->get_type()->size(); + if ( GenPoly::hasPolyBase( rdecl->get_type() ) ) ++n_poly_returns; + } + ++by_returns.at( n_returns ); + ++by_poly_returns.at( n_poly_returns ); + if ( n_returns > 0 ) ++p_poly_returns[ n_poly_returns*100/n_returns ]; + } + + public: + using Visitor::visit; + + virtual void visit( FunctionDecl *decl ) { + // skip if already seen declaration for this function + const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName(); + if ( ! seen_names.insert( mangleName ).second ) return; + + Stats& stats = for_linkage[ decl->get_linkage() ]; + + ++stats.n_decls; + FunctionType* fnTy = decl->get_functionType(); + const Type::ForallList& forall = fnTy->get_forall(); + ++stats.n_type_params.at( forall.size() ); + unsigned n_assertions = 0; + for ( TypeDecl* fdecl : forall ) { + n_assertions += fdecl->get_assertions().size(); + for ( DeclarationWithType* assn : fdecl->get_assertions() ) { + FunctionType *assnTy = 0; + if ( ObjectDecl *assnObj = dynamic_cast(assn) ) { + if ( PointerType *ptrTy = dynamic_cast(assnObj->get_type()) ) { + assnTy = dynamic_cast(ptrTy->get_base()); + } else assnTy = dynamic_cast(assnObj->get_type()); + } else if ( FunctionDecl *assnDecl = dynamic_cast(assn) ) { + assnTy = assnDecl->get_functionType(); + } + if ( assnTy ) analyzeFunc( assnTy, stats.n_assn_params, stats.n_assn_poly_params, stats.n_assn_returns, + stats.n_assn_poly_returns, stats.p_assn_poly_params, stats.p_assn_poly_returns ); + } + } + ++stats.n_assertions[ n_assertions ]; + + ++stats.by_name[ decl->get_name() ]; + + analyzeFunc( fnTy, stats.n_params, stats.n_poly_params, stats.n_returns, + stats.n_poly_returns, stats.p_poly_params, stats.p_poly_returns ); + } + + private: + template + void printAll( const char* name, F extract ) { + std::cout << "\"" << name << "\","; + for ( const auto& stats : for_linkage ) { + std::cout << "," << extract(stats); + } + std::cout << "," << extract(total) << std::endl; + } + + template + void printAllMap( const char* name, F extract ) { + for ( const auto& entry : extract(total) ) { + const auto& key = entry.first; + std::cout << "\"" << name << "\"," << key; + for ( const auto& stats : for_linkage ) { + const auto& map = extract(stats); + auto it = map.find( key ); + if ( it == map.end() ) std::cout << ",0"; + else std::cout << "," << it->second; + } + std::cout << "," << entry.second << std::endl; + } + } + + template + void printAllHisto( const char* name, F extract ) { + VectorMap histos[LinkageSpec::NoOfSpecs]; + VectorMap thisto; + + for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); } + + for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + // can't be a higher count in one of the sub-histograms than the total + histos[i].reserve( thisto.size() ); + + for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } + } + + for ( unsigned i = 0; i < thisto.size(); ++i ) { + std::cout << "\"" << name << "\"," << i; + for ( const auto& histo : histos ) { + std::cout << "," << histo[i]; + } + std::cout << "," << thisto[i] << std::endl; + } + } + + template + void printAllSparseHisto( const char* name, F extract ) { + std::map histos[LinkageSpec::NoOfSpecs]; + std::map thisto; + + for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; } + + for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } + } + + for ( const auto& entry : thisto ) { + const auto& key = entry.first; + std::cout << "\"" << name << "\"," << key; + for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { + auto it = histos[i].find( key ); + if ( it == histos[i].end() ) std::cout << ",0"; + else std::cout << "," << it->second; + } + std::cout << "," << entry.second << std::endl; + } + } + + public: + void print() { + for ( auto& stats : for_linkage ) { + total += stats; + } + + std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"builtin\",\"TOTAL\"" << std::endl; + + printAllMap("n_type_params", [](const Stats& stats) { return stats.n_type_params; }); + printAll("n_decls", [](const Stats& stats) { return stats.n_decls; }); + printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); + printAllSparseHisto("overloads", [](const Stats& stats) { return stats.by_name; }); + + printAllMap("n_poly_params", [](const Stats& stats) { return stats.n_poly_params; }); + printAllMap("n_params", [](const Stats& stats) { return stats.n_params; }); + printAllMap("%_poly_params", [](const Stats& stats) { return stats.p_poly_params; }); + printAllMap("n_poly_returns", [](const Stats& stats) { return stats.n_poly_returns; }); + printAllMap("n_returns", [](const Stats& stats) { return stats.n_returns; }); + printAllMap("%_poly_returns", [](const Stats& stats) { return stats.p_poly_returns; }); + + printAllMap("n_assertions", [](const Stats& stats) { return stats.n_assertions; }); + printAllMap("n_assn_poly_params", [](const Stats& stats) { return stats.n_assn_poly_params; }); + printAllMap("n_assn_params", [](const Stats& stats) { return stats.n_assn_params; }); + printAllMap("%_assn_poly_params", [](const Stats& stats) { return stats.p_assn_poly_params; }); + printAllMap("n_assn_poly_returns", [](const Stats& stats) { return stats.n_assn_poly_returns; }); + printAllMap("n_assn_returns", [](const Stats& stats) { return stats.n_assn_returns; }); + printAllMap("%_assn_poly_returns", [](const Stats& stats) { return stats.p_assn_poly_returns; }); + } + }; + + void printDeclStats( std::list< Declaration * > &translationUnit ) { + DeclStats stats; + acceptAll( translationUnit, stats ); + stats.print(); + } + +} // namespace CodeTools + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeTools/DeclStats.h =================================================================== --- src/CodeTools/DeclStats.h (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/CodeTools/DeclStats.h (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,34 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// DeclStats.h -- Prints summary information about a translation unit's declarations. +// +// Author : Aaron Moss +// Created On : Wed Jan 31 16:40:00 2016 +// Last Modified By : Aaron Moss +// Last Modified On : Wed Jan 31 16:40:00 2016 +// Update Count : 1 +// + +#ifndef DECLSTATS_H +#define DECLSTATS_H + +#include "SynTree/SynTree.h" + +namespace CodeTools { + + /// Prints summary information about a translation unit's function declarations and calls + void printDeclStats( std::list< Declaration * > &translationUnit ); + +} // namespace CodeTools + +#endif // DECLSTATS_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeTools/module.mk =================================================================== --- src/CodeTools/module.mk (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/CodeTools/module.mk (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,17 @@ +######################### -*- Mode: Makefile-Gmake -*- ######################## +## +## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +## +## The contents of this file are covered under the licence agreement in the +## file "LICENCE" distributed with Cforall. +## +## module.mk -- +## +## Author : Richard C. Bilson +## Created On : Mon Jun 1 17:49:17 2015 +## Last Modified By : Aaron Moss +## Last Modified On : Wed Jan 31 16:36:00 2017 +## Update Count : 2 +############################################################################### + +SRC += CodeTools/DeclStats.cc Index: src/Common/ScopedMap.h =================================================================== --- src/Common/ScopedMap.h (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/Common/ScopedMap.h (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -102,8 +102,8 @@ iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; } - bool operator== (const iterator &that) { + bool operator== (const iterator &that) const { return scopes == that.scopes && level == that.level && it == that.it; } - bool operator!= (const iterator &that) { return !( *this == that ); } + bool operator!= (const iterator &that) const { return !( *this == that ); } size_type get_level() const { return level; } @@ -180,8 +180,8 @@ const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } - bool operator== (const const_iterator &that) { + bool operator== (const const_iterator &that) const { return scopes == that.scopes && level == that.level && it == that.it; } - bool operator!= (const const_iterator &that) { return !( *this == that ); } + bool operator!= (const const_iterator &that) const { return !( *this == that ); } size_type get_level() const { return level; } Index: src/Common/VectorMap.h =================================================================== --- src/Common/VectorMap.h (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/Common/VectorMap.h (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,171 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ScopedMap.h -- +// +// Author : Aaron B. Moss +// Created On : Wed Feb 1 16:55:00 2017 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed Feb 1 16:55:00 2017 +// Update Count : 1 +// + +#ifndef _VECTORMAP_H +#define _VECTORMAP_H + +#include +#include +#include + +/// Maps integers from a contiguous range to T's +template +class VectorMap { + std::vector data; + +public: + typedef typename std::vector::size_type size_type; + typedef size_type key_type; + typedef T mapped_type; + typedef std::pair value_type; + typedef std::pair const_value_type; + typedef typename std::vector::difference_type difference_type; + typedef const value_type& reference; + typedef const const_value_type& const_reference; + typedef const value_type* pointer; + typedef const const_value_type* const_pointer; + + class iterator : public std::iterator< std::bidirectional_iterator_tag, + value_type, + difference_type, + pointer, + reference > { + friend class VectorMap; + friend class const_iterator; + + value_type data; + + iterator(size_type i, std::vector& v) : data(i, v[i]) {} + public: + iterator(const iterator& that) : data(that.data) {} + iterator& operator= (const iterator& that) { + new(&data) value_type{ that.data }; + return *this; + } + + reference operator* () { return data; } + pointer operator-> () { return &data; } + + iterator& operator++ () { + // SHENANIGANS: relies on pair having a trivial destructor and + // vector having contiguous layout + new(&data) value_type{ (data.first + 1), *(&data.second + 1) }; + return *this; + } + iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; } + + iterator& operator-- () { + // SHENANIGANS: same reasons as operator++ + new(&data) value_type{ (data.first - 1), *(&data.second - 1) }; + return *this; + } + iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const iterator& o) const { + return data.first == o.data.first && &data.second == &o.data.second; + } + bool operator!= (const iterator& that) const { return !(*this == that); } + }; + + class const_iterator : public std::iterator< std::bidirectional_iterator_tag, + const_value_type, + difference_type, + const_pointer, + const_reference > { + friend class VectorMap; + const_value_type data; + + const_iterator(size_type i, const std::vector& v) : data(i, v[i]) {} + public: + const_iterator(const iterator& that) : data(that.data) {} + const_iterator(const const_iterator& that) : data(that.data) {} + const_iterator& operator= (const iterator& that) { + new(&data) const_value_type{ that.data }; + return *this; + } + const_iterator& operator= (const const_iterator& that) { + new(&data) const_value_type{ that.data }; + return *this; + } + + const_reference operator* () { return data; } + const_pointer operator-> () { return &data; } + + const_iterator& operator++ () { + // SHENANIGANS: same reasons as iterator::operator++ + new(&data) const_value_type{ (data.first + 1), *(&data.second + 1) }; + return *this; + } + const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; } + + const_iterator& operator-- () { + // SHENANIGANS: same reasons as iterator::operator++ + new(&data) const_value_type{ (data.first - 1), *(&data.second - 1) }; + return *this; + } + const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const const_iterator& o) const { + return data.first == o.data.first && &data.second == &o.data.second; + } + bool operator!= (const const_iterator& that) const { return !(*this == that); } + }; + + /// Reserve space for n elements + void reserve(size_type n) { + if ( n > data.size() ) { data.insert( data.end(), n - data.size(), T{} ); } + } + + /// Unsafe access; no bounds checking + T& operator[] (size_type i) { return data[i]; } + const T& operator[] (size_type i) const { return data[i]; } + + /// Safe access; will insert new values if needed + T& at(size_type i) { + reserve(i+1); + return data[i]; + } + + /// Number of stored values + unsigned size() const { return data.size(); } + + /// No stored values + bool empty() const { return data.empty(); } + + /// Empties the map + void clear() { data.clear(); } + + /// Returns 1 if element in map, 0 otherwise + size_type count( size_type i ) const { return i < size() ? 1 : 0; } + + iterator begin() { return iterator{ 0, data }; } + const_iterator begin() const { return const_iterator{ 0, data }; } + const_iterator cbegin() const { return const_iterator{ 0, data }; } + + iterator end() { return iterator{ data.size(), data }; } + const_iterator end() const { return const_iterator{ data.size(), data }; } + const_iterator cend() const { return const_iterator{ data.size(), data }; } + + iterator find( size_type i ) { return i < size() ? iterator{ i, data } : end(); } + const_iterator find( size_type i ) const { return i < size() ? const_iterator{ i, data } : end(); } +}; + +#endif // _VECTORMAP_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/Makefile.am (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -26,4 +26,5 @@ include CodeGen/module.mk +include CodeTools/module.mk include Common/module.mk include ControlStruct/module.mk Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/Makefile.in (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -24,4 +24,7 @@ #SRC += ArgTweak/Rewriter.cc \ # ArgTweak/Mutate.cc + +######################### -*- Mode: Makefile-Gmake -*- ######################## +############################################################################### ######################### -*- Mode: Makefile-Gmake -*- ######################## @@ -71,5 +74,6 @@ build_triplet = @build@ host_triplet = @host@ -DIST_COMMON = $(srcdir)/CodeGen/module.mk $(srcdir)/Common/module.mk \ +DIST_COMMON = $(srcdir)/CodeGen/module.mk \ + $(srcdir)/CodeTools/module.mk $(srcdir)/Common/module.mk \ $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk \ $(srcdir)/InitTweak/module.mk $(srcdir)/Makefile.am \ @@ -99,4 +103,5 @@ CodeGen/driver_cfa_cpp-FixMain.$(OBJEXT) \ CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) \ + CodeTools/driver_cfa_cpp-DeclStats.$(OBJEXT) \ Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ @@ -376,6 +381,7 @@ CodeGen/CodeGenerator.cc CodeGen/GenType.cc \ CodeGen/FixNames.cc CodeGen/FixMain.cc \ - CodeGen/OperatorTable.cc Common/SemanticError.cc \ - Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \ + CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \ + Common/SemanticError.cc Common/UniqueName.cc \ + Common/DebugMalloc.cc Common/Assert.cc \ ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ @@ -440,5 +446,5 @@ .SUFFIXES: .SUFFIXES: .cc .ll .o .obj .yy -$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/CodeGen/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(am__configure_deps) +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ @@ -461,5 +467,5 @@ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; -$(srcdir)/CodeGen/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk: +$(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk: $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) @@ -526,4 +532,12 @@ CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT): \ CodeGen/$(am__dirstamp) CodeGen/$(DEPDIR)/$(am__dirstamp) +CodeTools/$(am__dirstamp): + @$(MKDIR_P) CodeTools + @: > CodeTools/$(am__dirstamp) +CodeTools/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) CodeTools/$(DEPDIR) + @: > CodeTools/$(DEPDIR)/$(am__dirstamp) +CodeTools/driver_cfa_cpp-DeclStats.$(OBJEXT): \ + CodeTools/$(am__dirstamp) CodeTools/$(DEPDIR)/$(am__dirstamp) Common/$(am__dirstamp): @$(MKDIR_P) Common @@ -813,4 +827,5 @@ -rm -f CodeGen/driver_cfa_cpp-Generate.$(OBJEXT) -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) + -rm -f CodeTools/driver_cfa_cpp-DeclStats.$(OBJEXT) -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT) -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) @@ -922,4 +937,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-Generate.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@ @@ -1148,4 +1164,18 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o CodeGen/driver_cfa_cpp-OperatorTable.obj `if test -f 'CodeGen/OperatorTable.cc'; then $(CYGPATH_W) 'CodeGen/OperatorTable.cc'; else $(CYGPATH_W) '$(srcdir)/CodeGen/OperatorTable.cc'; fi` +CodeTools/driver_cfa_cpp-DeclStats.o: CodeTools/DeclStats.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT CodeTools/driver_cfa_cpp-DeclStats.o -MD -MP -MF CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Tpo -c -o CodeTools/driver_cfa_cpp-DeclStats.o `test -f 'CodeTools/DeclStats.cc' || echo '$(srcdir)/'`CodeTools/DeclStats.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Tpo CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='CodeTools/DeclStats.cc' object='CodeTools/driver_cfa_cpp-DeclStats.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o CodeTools/driver_cfa_cpp-DeclStats.o `test -f 'CodeTools/DeclStats.cc' || echo '$(srcdir)/'`CodeTools/DeclStats.cc + +CodeTools/driver_cfa_cpp-DeclStats.obj: CodeTools/DeclStats.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT CodeTools/driver_cfa_cpp-DeclStats.obj -MD -MP -MF CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Tpo -c -o CodeTools/driver_cfa_cpp-DeclStats.obj `if test -f 'CodeTools/DeclStats.cc'; then $(CYGPATH_W) 'CodeTools/DeclStats.cc'; else $(CYGPATH_W) '$(srcdir)/CodeTools/DeclStats.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Tpo CodeTools/$(DEPDIR)/driver_cfa_cpp-DeclStats.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='CodeTools/DeclStats.cc' object='CodeTools/driver_cfa_cpp-DeclStats.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o CodeTools/driver_cfa_cpp-DeclStats.obj `if test -f 'CodeTools/DeclStats.cc'; then $(CYGPATH_W) 'CodeTools/DeclStats.cc'; else $(CYGPATH_W) '$(srcdir)/CodeTools/DeclStats.cc'; fi` + Common/driver_cfa_cpp-SemanticError.o: Common/SemanticError.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-SemanticError.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Tpo -c -o Common/driver_cfa_cpp-SemanticError.o `test -f 'Common/SemanticError.cc' || echo '$(srcdir)/'`Common/SemanticError.cc @@ -2631,4 +2661,6 @@ -rm -f CodeGen/$(DEPDIR)/$(am__dirstamp) -rm -f CodeGen/$(am__dirstamp) + -rm -f CodeTools/$(DEPDIR)/$(am__dirstamp) + -rm -f CodeTools/$(am__dirstamp) -rm -f Common/$(DEPDIR)/$(am__dirstamp) -rm -f Common/$(am__dirstamp) @@ -2664,5 +2696,5 @@ distclean: distclean-am - -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) Common/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) + -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ @@ -2710,5 +2742,5 @@ maintainer-clean: maintainer-clean-am - -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) Common/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) + -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/ResolvExpr/Resolver.cc (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -449,4 +449,5 @@ TypeSubstitution sub = makeGenericSubstitutuion( sit ); StructDecl * st = sit->get_baseStruct(); + if(st->get_members().empty()) return; // want to resolve each initializer to the members of the struct, // but if there are more initializers than members we should stop @@ -458,4 +459,5 @@ TypeSubstitution sub = makeGenericSubstitutuion( uit ); UnionDecl * un = uit->get_baseUnion(); + if(un->get_members().empty()) return; // only resolve to the first member of a union resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub ); Index: src/benchmark/CorCtxSwitch.c =================================================================== --- src/benchmark/CorCtxSwitch.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/benchmark/CorCtxSwitch.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,67 @@ +#include +#include +#include + +#include // sysconf +#include // times +#include + +inline unsigned long long int Time() { + timespec ts; + clock_gettime( +#if defined( __linux__ ) + CLOCK_THREAD_CPUTIME_ID, +#elif defined( __freebsd__ ) + CLOCK_PROF, +#elif defined( __solaris__ ) + CLOCK_HIGHRES, +#else + #error uC++ : internal error, unsupported architecture +#endif + &ts ); + return 1000000000LL * ts.tv_sec + ts.tv_nsec; +} // Time + +struct GreatSuspender { + coroutine c; +}; + +DECL_COROUTINE(GreatSuspender); + +void ?{}( GreatSuspender * this ) { + prime(this); +} + +void main( GreatSuspender * this ) +{ + while( true ) { + suspend(); + } +} + +void resumer( GreatSuspender * this, const unsigned int NoOfTimes ) { + for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { + resume( this ); + } +} + +#ifndef N +#define N 100000000 +#endif + +int main() { + const unsigned int NoOfTimes = N; + long long int StartTime, EndTime; + + GreatSuspender s; + + StartTime = Time(); + // for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { + // resume( this_coroutine() ); + // // resume( &s ); + // } + resumer( &s, NoOfTimes ); + EndTime = Time(); + + sout | ( EndTime - StartTime ) / NoOfTimes | endl; +} Index: src/benchmark/Makefile.am =================================================================== --- src/benchmark/Makefile.am (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/benchmark/Makefile.am (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,45 @@ +######################## -*- Mode: Makefile-Automake -*- ###################### +## +## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +## +## The contents of this file are covered under the licence agreement in the +## file "LICENCE" distributed with Cforall. +## +## Makefile.am -- +## +## Author : Peter A. Buhr +## Created On : Sun May 31 09:08:15 2015 +## Last Modified By : Peter A. Buhr +## Last Modified On : Mon Jan 25 22:31:42 2016 +## Update Count : 25 +############################################################################### + +# applies to both programs +CFLAGS = +AM_CFLAGS = -g -Wall -Wno-unused-function -O2 +CC = @CFA_BINDIR@/cfa + +noinst_PROGRAMS = bench ctxswitch-coroutine ctxswitch-thread + +bench : + @for ccflags in "-debug" "-nodebug"; do \ + echo ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\ + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\ + ./a.out ; \ + done ; \ + rm -f ./a.out ; + +ctxswitch-coroutine: + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -nodebug -lrt -DN=10000000 CorCtxSwitch.c + @for number in 1 2 3 4 5 6 7 8 9 10; do \ + ./a.out ; \ + done + @rm -f ./a.out + +ctxswitch-thread: + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -nodebug -lrt -DN=10000000 ThrdCtxSwitch.c + @for number in 1 2 3 4 5 6 7 8 9 10; do \ + ./a.out ; \ + done + @rm -f ./a.out + Index: src/benchmark/Makefile.in =================================================================== --- src/benchmark/Makefile.in (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/benchmark/Makefile.in (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,495 @@ +# Makefile.in generated by automake 1.11.3 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +######################## -*- Mode: Makefile-Automake -*- ###################### +############################################################################### + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +noinst_PROGRAMS = bench$(EXEEXT) ctxswitch-coroutine$(EXEEXT) \ + ctxswitch-thread$(EXEEXT) +subdir = src/benchmark +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +PROGRAMS = $(noinst_PROGRAMS) +bench_SOURCES = bench.c +bench_OBJECTS = bench.$(OBJEXT) +bench_LDADD = $(LDADD) +ctxswitch_coroutine_SOURCES = ctxswitch-coroutine.c +ctxswitch_coroutine_OBJECTS = ctxswitch-coroutine.$(OBJEXT) +ctxswitch_coroutine_LDADD = $(LDADD) +ctxswitch_thread_SOURCES = ctxswitch-thread.c +ctxswitch_thread_OBJECTS = ctxswitch-thread.$(OBJEXT) +ctxswitch_thread_LDADD = $(LDADD) +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/automake/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_@AM_V@) +am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) +am__v_CC_0 = @echo " CC " $@; +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +CCLD = $(CC) +LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_@AM_V@) +am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) +am__v_CCLD_0 = @echo " CCLD " $@; +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +SOURCES = bench.c ctxswitch-coroutine.c ctxswitch-thread.c +DIST_SOURCES = bench.c ctxswitch-coroutine.c ctxswitch-thread.c +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +ALLOCA = @ALLOCA@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BACKEND_CC = @BACKEND_CC@ +CC = @CFA_BINDIR@/cfa +CCAS = @CCAS@ +CCASDEPMODE = @CCASDEPMODE@ +CCASFLAGS = @CCASFLAGS@ +CCDEPMODE = @CCDEPMODE@ +CFA_BACKEND_CC = @CFA_BACKEND_CC@ +CFA_BINDIR = @CFA_BINDIR@ +CFA_FLAGS = @CFA_FLAGS@ +CFA_INCDIR = @CFA_INCDIR@ +CFA_LIBDIR = @CFA_LIBDIR@ +CFA_PREFIX = @CFA_PREFIX@ + +# applies to both programs +CFLAGS = +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LDFLAGS = @LDFLAGS@ +LEX = @LEX@ +LEXLIB = @LEXLIB@ +LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +MACHINE_TYPE = @MACHINE_TYPE@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +OBJEXT = @OBJEXT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +RANLIB = @RANLIB@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +YACC = @YACC@ +YFLAGS = @YFLAGS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CFLAGS = -g -Wall -Wno-unused-function -O2 +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/benchmark/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/benchmark/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +clean-noinstPROGRAMS: + -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bench.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ctxswitch-coroutine.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ctxswitch-thread.Po@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c $< + +.c.obj: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'` + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(PROGRAMS) +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-noinstPROGRAMS mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-noinstPROGRAMS ctags distclean distclean-compile \ + distclean-generic distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \ + uninstall-am + + +bench : + @for ccflags in "-debug" "-nodebug"; do \ + echo ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\ + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\ + ./a.out ; \ + done ; \ + rm -f ./a.out ; + +ctxswitch-coroutine: + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -nodebug -lrt -DN=10000000 CorCtxSwitch.c + @for number in 1 2 3 4 5 6 7 8 9 10; do \ + ./a.out ; \ + done + @rm -f ./a.out + +ctxswitch-thread: + ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -nodebug -lrt -DN=10000000 ThrdCtxSwitch.c + @for number in 1 2 3 4 5 6 7 8 9 10; do \ + ./a.out ; \ + done + @rm -f ./a.out + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: Index: src/benchmark/ThrdCtxSwitch.c =================================================================== --- src/benchmark/ThrdCtxSwitch.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/benchmark/ThrdCtxSwitch.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,40 @@ +#include +#include +#include + +#include // sysconf +#include // times +#include + +inline unsigned long long int Time() { + timespec ts; + clock_gettime( +#if defined( __linux__ ) + CLOCK_THREAD_CPUTIME_ID, +#elif defined( __freebsd__ ) + CLOCK_PROF, +#elif defined( __solaris__ ) + CLOCK_HIGHRES, +#else + #error uC++ : internal error, unsupported architecture +#endif + &ts ); + return 1000000000LL * ts.tv_sec + ts.tv_nsec; +} // Time + +#ifndef N +#define N 100000000 +#endif + +int main() { + const unsigned int NoOfTimes = N; + long long int StartTime, EndTime; + + StartTime = Time(); + for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { + yield(); + } + EndTime = Time(); + + sout | ( EndTime - StartTime ) / NoOfTimes | endl; +} Index: src/benchmark/bench.c =================================================================== --- src/benchmark/bench.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/benchmark/bench.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,246 @@ + +#include +#include +#include + +#include // sysconf +#include // times +#include + +inline unsigned long long int Time() { + timespec ts; + clock_gettime( +#if defined( __linux__ ) + CLOCK_THREAD_CPUTIME_ID, +#elif defined( __freebsd__ ) + CLOCK_PROF, +#elif defined( __solaris__ ) + CLOCK_HIGHRES, +#else + #error uC++ : internal error, unsupported architecture +#endif + &ts ); + return 1000000000LL * ts.tv_sec + ts.tv_nsec; +} // Time + +//======================================= +// time struct +//======================================= + +// prevent dead-code removal +struct StructDummy { + volatile int i; +}; + +void ?{}(StructDummy * this) __attribute__(( noinline )) { + this->i = 2; +} + +int get_i(StructDummy * this) { + return this->i; +} + +forall( dtype T | { int get_i(T*); } ) +int bidirectional( StructDummy * this ) __attribute__(( noinline )) { + return get_i( this ); +} + +void BlockStructCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + StructDummy dummy; + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +void DynamicStructCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + StructDummy *dummy = new(); + delete(dummy); + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +void StructBidirectional( int N ) { + long long int StartTime, EndTime; + StructDummy dummy; + volatile int rv __attribute__(( unused )); + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + rv = bidirectional( &dummy ); + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +//======================================= +// time coroutine +//======================================= + +struct CoroutineDummy { coroutine c; }; +DECL_COROUTINE(CoroutineDummy); +void main(CoroutineDummy * this) {} + +void ?{}(CoroutineDummy * this) { + prime(this); +} + +void BlockCoroutineCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + CoroutineDummy dummy; + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +void DynamicCoroutineCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + CoroutineDummy * dummy = new(); + delete(dummy); + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +struct CoroutineResume { + int N; + coroutine c; +}; + +DECL_COROUTINE(CoroutineResume); + +void ?{}(CoroutineResume* this, int N) { + this->N = N; + prime(this); +} + +void main(CoroutineResume* this) { + for ( int i = 1; i <= this->N; i += 1 ) { + suspend(); + } +} + +void resumer(CoroutineResume* this) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 1; i <= this->N; i += 1 ) { + resume(this); + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / this->N; +} + +//======================================= +// time task +//======================================= + +struct ThreadDummy { thread t; }; +DECL_THREAD(ThreadDummy); +void main(ThreadDummy * this) {} + +void BlockTaskCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + scoped(ThreadDummy) dummy; + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +void DynamicTaskCreateDelete( int N ) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 0; i < N; i += 1 ) { + scoped(ThreadDummy) * dummy = new(); + delete(dummy); + } + EndTime = Time(); + sout | "\t " | ( EndTime - StartTime ) / N; +} + +struct ContextSwitch { + int N; + long long result; + thread t; +}; + +DECL_THREAD(ContextSwitch); + +void main(ContextSwitch * this) { + long long int StartTime, EndTime; + + StartTime = Time(); + for ( int i = 1; i <= this->N; i += 1 ) { + yield(); + } // for + EndTime = Time(); + this->result = ( EndTime - StartTime ) / this->N; +} + +void ?{}(ContextSwitch * this, int N) { + this->N = N; +} + +void ^?{}(ContextSwitch * this) { + sout | "\t " | this->result; +} + +//======================================= +// benchmark driver +//======================================= + + +int main() { + const int NoOfTimes = +#if defined( __U_DEBUG__ ) // takes longer so run fewer iterations + 100000; +#else + 1000000; +#endif // __U_DEBUG__ + + sout | "\t\tcreate\tcreate\tcall/" | endl; + sout | "(nsecs)"; + sout | "\t\tdelete/\tdelete/\tctx" | endl; + sout | "\t\tblock\tdynamic\tcycle" | endl; + + sout | "object\t"; + BlockStructCreateDelete( NoOfTimes ); + DynamicStructCreateDelete( NoOfTimes ); + StructBidirectional( NoOfTimes ); + sout | endl; + + sout | "coroutine"; + BlockCoroutineCreateDelete( NoOfTimes ); + DynamicCoroutineCreateDelete( NoOfTimes ); + { + CoroutineResume resumer = { NoOfTimes }; + resumer(&resumer); + } + sout | endl; + + sout | "task\t"; + BlockTaskCreateDelete( NoOfTimes ); + DynamicTaskCreateDelete( NoOfTimes ); + { + scoped(ContextSwitch) dummy = { (int)NoOfTimes }; // context switch + } + sout | "\t" | endl; +} Index: c/examples/Bench.c =================================================================== --- src/examples/Bench.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ (revision ) @@ -1,93 +1,0 @@ - - -#include -#include - -#include // sysconf -#include // times -#include - -inline unsigned long long int Time() { - timespec ts; - clock_gettime( -#if defined( __linux__ ) - CLOCK_THREAD_CPUTIME_ID, -#elif defined( __freebsd__ ) - CLOCK_PROF, -#elif defined( __solaris__ ) - CLOCK_HIGHRES, -#else - #error uC++ : internal error, unsupported architecture -#endif - &ts ); - return 1000000000LL * ts.tv_sec + ts.tv_nsec; -} // Time - -//======================================= -// time coroutine -//======================================= - -struct CoroutineResume { - int N; - coroutine c; -}; - -coroutine* get_coroutine(CoroutineResume* this); -void co_main(CoroutineResume* this); - -void ?{}(CoroutineResume* this, int N) { - this->N = N; - prime(this); -} - -coroutine* get_coroutine(CoroutineResume* this) { - return &this->c; -} - -void co_main(CoroutineResume* this) { - for ( int i = 1; i <= this->N; i += 1 ) { - suspend(); - } // for -} // CoroutineResume::main - -void resumer(CoroutineResume* this) { - long long int StartTime, EndTime; - - StartTime = Time(); - for ( int i = 1; i <= this->N; i += 1 ) { - resume(this); - } // for - EndTime = Time(); - sout | "\t " | ( EndTime - StartTime ) / this->N; -} // CoroutineResume::resumer - - -int main() { - const int NoOfTimes = -#if defined( __U_DEBUG__ ) // takes longer so run fewer iterations - 100000; -#else - 1000000; -#endif // __U_DEBUG__ - - sout | "\t\tcreate\tcreate\t16i/4o\t16i/4o\tresume/\tsignal/" | endl; - sout | "(nsecs)"; - sout | "\t\tdelete/\tdelete/\tbytes\tbytes\tsuspend\twait" | endl; - sout | "\t\tblock\tdynamic\tdirect\taccept\tcycle\tcycle" | endl; - - sout | "class\t"; - sout | "\t N/A\t N/A\t N/A"; - sout | "\t N/A\t N/A\t N/A"; - sout | "\t" | endl; - - sout | "coroutine"; - sout | "\t N/A\t N/A\t N/A"; - sout | "\t N/A"; - { - CoroutineResume resumer = { NoOfTimes }; - resumer(&resumer); - } - sout | "\t N/A"; - - sout | "\t" | endl; -} Index: c/examples/thread.c =================================================================== --- src/examples/thread.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ (revision ) @@ -1,55 +1,0 @@ -#include -#include -#include -#include - -// Start coroutine routines -struct MyThread { - thread t; - unsigned id; - unsigned count; -}; - -DECL_THREAD(MyThread) - -void ?{}( MyThread * this ) { -} - -void ?{}( MyThread * this, unsigned id, unsigned count ) { - this->id = id; - this->count = count; -} - -void main(MyThread* this) { - sout | "Thread" | this->id | " : Suspending" | this->count | "times" | endl; - yield(); - - for(int i = 0; i < this->count; i++) { - sout | "Thread" | this->id | " : Suspend No." | i + 1 | endl; - yield(); - } -} - -int main(int argc, char* argv[]) { - - unsigned itterations = 10u; - if(argc == 2) { - int val = ato(argv[1]); - assert(val >= 0); - itterations = val; - } - - sout | "User main begin" | endl; - - { - processor p; - { - scoped(MyThread) thread1 = { 1u, itterations }; - scoped(MyThread) thread2 = { 2u, itterations }; - } - } - - sout | "User main end" | endl; - - return 0; -} Index: src/libcfa/concurrency/CtxSwitch-x86_64.S =================================================================== --- src/libcfa/concurrency/CtxSwitch-x86_64.S (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/CtxSwitch-x86_64.S (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -49,4 +49,7 @@ // Save volatile registers on the stack. + subq $8,%rsp + stmxcsr 0(%rsp) // 4 bytes + fnstcw 4(%rsp) // 2 bytes pushq %r15 pushq %r14 @@ -72,4 +75,7 @@ popq %r14 popq %r15 + fldcw 4(%rsp) + ldmxcsr 0(%rsp) + addq $8,%rsp // Return to thread. Index: src/libcfa/concurrency/coroutines =================================================================== --- src/libcfa/concurrency/coroutines (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/coroutines (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -30,5 +30,5 @@ }; -#define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this); +#define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this) //----------------------------------------------------------------------------- @@ -65,5 +65,5 @@ // Private wrappers for context switch and stack creation -extern void corCxtSw(coroutine * src, coroutine * dst); +extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst); extern void create_stack( coStack_t * this, unsigned int storageSize ); @@ -81,5 +81,5 @@ src->name, src, src->last->name, src->last ); - corCxtSw( src, src->last ); + CoroutineCtxSwitch( src, src->last ); } @@ -107,5 +107,23 @@ // always done for performance testing - corCxtSw( src, dst ); + CoroutineCtxSwitch( src, dst ); +} + +static inline void resume(coroutine * dst) { + coroutine * src = this_coroutine(); // optimization + + // not resuming self ? + if ( src != dst ) { + assertf( dst->notHalted , + "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n" + "Possible cause is terminated coroutine's main routine has already returned.", + src->name, src, dst->name, dst ); + + // set last resumer + dst->last = src; + } // if + + // always done for performance testing + CoroutineCtxSwitch( src, dst ); } Index: src/libcfa/concurrency/coroutines.c =================================================================== --- src/libcfa/concurrency/coroutines.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/coroutines.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -98,11 +98,6 @@ } -// We need to call suspend from invoke.c, so we expose this wrapper that -// is not inline (We can't inline Cforall in C) -void suspend_no_inline(void) { - suspend(); -} - -void corCxtSw(coroutine* src, coroutine* dst) { +// Wrapper for co +void CoroutineCtxSwitch(coroutine* src, coroutine* dst) { // THREAD_GETMEM( This )->disableInterrupts(); @@ -167,4 +162,12 @@ } +// We need to call suspend from invoke.c, so we expose this wrapper that +// is not inline (We can't inline Cforall in C) +extern "C" { + void __suspend_internal(void) { + suspend(); + } +} + // Local Variables: // // mode: c // Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/invoke.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -28,6 +28,6 @@ // Called from the kernel when starting a coroutine or task so must switch back to user mode. -extern void __suspend_no_inline__F___1(void); -extern void __signal_termination__F_P7sthread__1(struct thread*); +extern void __suspend_internal(void); +extern void __thread_signal_termination(struct thread*); void CtxInvokeCoroutine( @@ -41,5 +41,5 @@ if(cor->state == Primed) { - __suspend_no_inline__F___1(); + __suspend_internal(); } @@ -52,6 +52,6 @@ //Final suspend, should never return - __suspend_no_inline__F___1(); - assertf(false, "Resumed dead coroutine"); + __suspend_internal(); + abortf("Resumed dead coroutine"); } @@ -61,7 +61,5 @@ void *this ) { - // LIB_DEBUG_PRINTF("Invoke Thread : Received %p (main %p, get_t %p)\n", this, main, get_thread); - - __suspend_no_inline__F___1(); + __suspend_internal(); struct thread* thrd = get_thread( this ); @@ -72,9 +70,9 @@ main( this ); - __signal_termination__F_P7sthread__1(thrd); + __thread_signal_termination(thrd); //Final suspend, should never return - __suspend_no_inline__F___1(); - assertf(false, "Resumed dead thread"); + __suspend_internal(); + abortf("Resumed dead thread"); } @@ -111,5 +109,7 @@ struct FakeStack { void *fixedRegisters[5]; // fixed registers rbx, r12, r13, r14, r15 - void *rturn; // where to go on return from uSwitch + uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) + uint16_t fcw; // X97 FPU control word (preserved across function calls) + void *rturn; // where to go on return from uSwitch void *dummyReturn; // NULL return address to provide proper alignment }; @@ -122,4 +122,6 @@ ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this; ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke; + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 #else #error Only __i386__ and __x86_64__ is supported for threads in cfa Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/kernel.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -15,4 +15,8 @@ // +//Start and stop routine for the kernel, declared first to make sure they run first +void kernel_startup(void) __attribute__((constructor(101))); +void kernel_shutdown(void) __attribute__((destructor(101))); + //Header #include "kernel" @@ -39,5 +43,5 @@ }; -DECL_COROUTINE(processorCtx_t) +DECL_COROUTINE(processorCtx_t); #define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)] @@ -52,7 +56,4 @@ processor * systemProcessor; thread * mainThread; - -void kernel_startup(void) __attribute__((constructor(101))); -void kernel_shutdown(void) __attribute__((destructor(101))); //----------------------------------------------------------------------------- @@ -184,5 +185,5 @@ void main(processorCtx_t * ctx); thread * nextThread(cluster * this); -void runThread(processor * this, thread * dst); +void scheduleInternal(processor * this, thread * dst); void spin(processor * this, unsigned int * spin_count); @@ -197,5 +198,5 @@ if(readyThread) { - runThread(this, readyThread); + scheduleInternal(this, readyThread); spin_count = 0; } else { @@ -209,25 +210,45 @@ } -void runThread(processor * this, thread * dst) { +//Declarations for scheduleInternal +extern void ThreadCtxSwitch(coroutine * src, coroutine * dst); + +// scheduleInternal runs a thread by context switching +// from the processor coroutine to the target thread +void scheduleInternal(processor * this, thread * dst) { + // coroutine * proc_ctx = get_coroutine(this->ctx); + // coroutine * thrd_ctx = get_coroutine(dst); + + // //Update global state + // this->current_thread = dst; + + // // Context Switch to the thread + // ThreadCtxSwitch(proc_ctx, thrd_ctx); + // // when ThreadCtxSwitch returns we are back in the processor coroutine + coroutine * proc_ctx = get_coroutine(this->ctx); coroutine * thrd_ctx = get_coroutine(dst); - thrd_ctx->last = proc_ctx; - - // context switch to specified coroutine - // Which is now the current_coroutine - // LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine); - this->current_thread = dst; - this->current_coroutine = thrd_ctx; - CtxSwitch( proc_ctx->stack.context, thrd_ctx->stack.context ); - this->current_coroutine = proc_ctx; - // LIB_DEBUG_PRINTF("Kernel : returned from ctx %p (to %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine); - - // when CtxSwitch returns we are back in the processor coroutine -} - + thrd_ctx->last = proc_ctx; + + // context switch to specified coroutine + // Which is now the current_coroutine + LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p, current %p)\n", thrd_ctx, proc_ctx, this->current_coroutine); + this->current_thread = dst; + this->current_coroutine = thrd_ctx; + CtxSwitch( proc_ctx->stack.context, thrd_ctx->stack.context ); + this->current_coroutine = proc_ctx; + LIB_DEBUG_PRINTF("Kernel : returned from ctx %p (to %p, current %p)\n", thrd_ctx, proc_ctx, this->current_coroutine); + + // when CtxSwitch returns we are back in the processor coroutine +} + +// Handles spinning logic +// TODO : find some strategy to put cores to sleep after some time void spin(processor * this, unsigned int * spin_count) { (*spin_count)++; } +// Context invoker for processors +// This is the entry point for processors (kernel threads) +// It effectively constructs a coroutine by stealing the pthread stack void * CtxInvokeProcessor(void * arg) { processor * proc = (processor *) arg; @@ -241,17 +262,10 @@ processorCtx_t proc_cor_storage = { proc, &info }; + //Set global state proc->current_coroutine = &proc->ctx->c; proc->current_thread = NULL; + //We now have a proper context from which to schedule threads LIB_DEBUG_PRINTF("Kernel : core %p created (%p)\n", proc, proc->ctx); - - // LIB_DEBUG_PRINTF("Kernel : core base : %p \n", info.base ); - // LIB_DEBUG_PRINTF("Kernel : core storage : %p \n", info.storage ); - // LIB_DEBUG_PRINTF("Kernel : core size : %x \n", info.size ); - // LIB_DEBUG_PRINTF("Kernel : core limit : %p \n", info.limit ); - // LIB_DEBUG_PRINTF("Kernel : core context : %p \n", info.context ); - // LIB_DEBUG_PRINTF("Kernel : core top : %p \n", info.top ); - - //We now have a proper context from which to schedule threads // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't @@ -264,4 +278,5 @@ proc_cor_storage.c.notHalted = false; + // Main routine of the core returned, the core is now fully terminated LIB_DEBUG_PRINTF("Kernel : core %p main ended (%p)\n", proc, proc->ctx); Index: src/libcfa/concurrency/threads =================================================================== --- src/libcfa/concurrency/threads (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/threads (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -27,12 +27,12 @@ // Anything that implements this trait can be resumed. // Anything that is resumed is a coroutine. -trait is_thread(dtype T | sized(T)) { +trait is_thread(dtype T) { void main(T* this); thread* get_thread(T* this); }; -#define DECL_THREAD(X) static inline thread* get_thread(X* this) { return &this->t; } void main(X* this); +#define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this) -forall( dtype T | sized(T) | is_thread(T) ) +forall( dtype T | is_thread(T) ) static inline coroutine* get_coroutine(T* this) { return &get_thread(this)->c; Index: src/libcfa/concurrency/threads.c =================================================================== --- src/libcfa/concurrency/threads.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/concurrency/threads.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -31,8 +31,8 @@ //----------------------------------------------------------------------------- // Forward declarations -forall( dtype T | sized(T) | is_thread(T) ) +forall( dtype T | is_thread(T) ) void start( T* this ); -forall( dtype T | sized(T) | is_thread(T) ) +forall( dtype T | is_thread(T) ) void stop( T* this ); @@ -78,5 +78,5 @@ extern void thread_schedule( thread * ); -forall( dtype T | sized(T) | is_thread(T) ) +forall( dtype T | is_thread(T) ) void start( T* this ) { coroutine* thrd_c = get_coroutine(this); @@ -85,5 +85,5 @@ get_this_processor()->current_coroutine = thrd_c; - // LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", handle, thrd_c, thrd_h); + LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); create_stack(&thrd_c->stack, thrd_c->stack.size); @@ -91,8 +91,10 @@ CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); + LIB_DEBUG_PRINTF("Thread started : %p (t %p, c %p)\n", this, thrd_c, thrd_h); + thread_schedule(thrd_h); } -forall( dtype T | sized(T) | is_thread(T) ) +forall( dtype T | is_thread(T) ) void stop( T* this ) { thread* thrd = get_thread(this); @@ -102,13 +104,34 @@ } -void signal_termination( thread * this ) { - this->c.state = Halt; - this->c.notHalted = false; - unlock( &this->lock ); -} - void yield( void ) { thread_schedule( this_thread() ); suspend(); +} + +void ThreadCtxSwitch(coroutine* src, coroutine* dst) { + dst->last = src; + + // set state of current coroutine to inactive + src->state = Inactive; + + // set new coroutine that task is executing + get_this_processor()->current_coroutine = dst; + + // context switch to specified coroutine + CtxSwitch( src->stack.context, dst->stack.context ); + // when CtxSwitch returns we are back in the src coroutine + + // set state of new coroutine to active + src->state = Active; +} + +// C Helper to signal the termination of a thread +// Used in invoke.c +extern "C" { + void __thread_signal_termination( thread * this ) { + this->c.state = Halt; + this->c.notHalted = false; + unlock( &this->lock ); + } } Index: src/libcfa/containers/vector =================================================================== --- src/libcfa/containers/vector (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/containers/vector (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -118,9 +118,9 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -static inline const T* cbegin(const vector(T, allocator_t)* this) -{ - return data(&this->storage); -} +// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// static inline const T* cbegin(const vector(T, allocator_t)* this) +// { +// return data(&this->storage); +// } forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) @@ -130,9 +130,9 @@ } -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -static inline const T* cend(const vector(T, allocator_t)* this) -{ - return data(&this->storage) + this->size; -} +// forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +// static inline const T* cend(const vector(T, allocator_t)* this) +// { +// return data(&this->storage) + this->size; +// } //------------------------------------------------------------------------------ Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/stdlib (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -29,17 +29,17 @@ extern "C" { void * malloc( size_t ); } // use default C routine for void * -forall( otype T ) T * malloc( void ); -forall( otype T ) T * malloc( char fill ); -forall( otype T ) T * malloc( T * ptr, size_t size ); -forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ); +forall( dtype T | sized(T) ) T * malloc( void ); +forall( dtype T | sized(T) ) T * malloc( char fill ); +forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ); +forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ); extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void * -forall( otype T ) T * calloc( size_t nmemb ); +forall( dtype T | sized(T) ) T * calloc( size_t nmemb ); extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * -forall( otype T ) T * realloc( T * ptr, size_t size ); -forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ); +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ); +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ); -forall( otype T ) T * aligned_alloc( size_t alignment ); -forall( otype T ) T * memalign( size_t alignment ); // deprecated -forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ); +forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ); +forall( dtype T | sized(T) ) T * memalign( size_t alignment ); // deprecated +forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ); extern "C" { @@ -48,5 +48,5 @@ } // extern "C" -forall( otype T, ttype Params | { void ?{}(T *, Params); } ) T * new( Params p ); +forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); forall( dtype T | { void ^?{}(T *); } ) void delete( T * ptr ); Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/libcfa/stdlib.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -27,24 +27,24 @@ } // extern "C" -forall( otype T ) T * malloc( void ) { +forall( dtype T | sized(T) ) T * malloc( void ) { //printf( "malloc1\n" ); - return (T *)malloc( sizeof(T) ); -} // malloc -forall( otype T ) T * malloc( char fill ) { + return (T *)(void*)malloc( (size_t)sizeof(T) ); +} // malloc +forall( dtype T | sized(T) ) T * malloc( char fill ) { //printf( "malloc3\n" ); - T * ptr = (T *)malloc( sizeof(T) ); + T * ptr = (T *)(void*)malloc( (size_t)sizeof(T) ); return memset( ptr, (int)fill, sizeof(T) ); } // malloc -forall( otype T ) T * calloc( size_t nmemb ) { +forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { //printf( "calloc\n" ); return (T *)calloc( nmemb, sizeof(T) ); } // calloc -forall( otype T ) T * realloc( T * ptr, size_t size ) { +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { //printf( "realloc1\n" ); return (T *)(void *)realloc( (void *)ptr, size ); } // realloc -forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) { +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { //printf( "realloc2\n" ); char * nptr = (T *)(void *)realloc( (void *)ptr, size ); @@ -54,29 +54,29 @@ } // realloc -forall( otype T ) T * malloc( T * ptr, size_t size ) { +forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { //printf( "malloc4\n" ); return (T *)realloc( ptr, size ); } // malloc -forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) { +forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) { //printf( "malloc5\n" ); return (T *)realloc( ptr, size, fill ); } // malloc -forall( otype T ) T * aligned_alloc( size_t alignment ) { +forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { //printf( "aligned_alloc\n" ); return (T *)memalign( alignment, sizeof(T) ); } // aligned_alloc -forall( otype T ) T * memalign( size_t alignment ) { +forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { //printf( "memalign\n" ); return (T *)memalign( alignment, sizeof(T) ); } // memalign -forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) { +forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { //printf( "posix_memalign\n" ); return posix_memalign( (void **)ptr, alignment, sizeof(T) ); } // posix_memalign -forall( otype T, ttype Params | { void ?{}(T *, Params); } ) +forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ) { return ((T*)malloc()){ p }; Index: src/main.cc =================================================================== --- src/main.cc (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/main.cc (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -35,4 +35,5 @@ #include "CodeGen/FixNames.h" #include "CodeGen/FixMain.h" +#include "CodeTools/DeclStats.h" #include "ControlStruct/Mutate.h" #include "SymTab/Validate.h" @@ -61,4 +62,5 @@ bboxp = false, ctorinitp = false, + declstatsp = false, exprp = false, expraltp = false, @@ -244,4 +246,10 @@ } // if + if ( declstatsp ) { + CodeTools::printDeclStats( translationUnit ); + deleteAll( translationUnit ); + return 0; + } + if ( bresolvep ) { dump( translationUnit ); @@ -339,5 +347,5 @@ void parse_cmdline( int argc, char * argv[], const char *& filename ) { - enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, }; + enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, }; static struct option long_opts[] = { @@ -346,4 +354,5 @@ { "before-resolver", no_argument, 0, Bresolver }, { "ctorinitfix", no_argument, 0, CtorInitFix }, + { "decl-stats", no_argument, 0, DeclStats }, { "expr", no_argument, 0, Expr }, { "expralt", no_argument, 0, ExprAlt }, @@ -365,5 +374,5 @@ int c; - while ( (c = getopt_long( argc, argv, "abBcefglmnpqrstTvyzD:F:", long_opts, &long_index )) != -1 ) { + while ( (c = getopt_long( argc, argv, "abBcdefglmnpqrstTvyzD:F:", long_opts, &long_index )) != -1 ) { switch ( c ) { case Ast: @@ -381,4 +390,8 @@ case 'c': ctorinitp = true; + break; + case DeclStats: + case 'd': + declstatsp = true; break; case Expr: Index: src/prelude/Makefile.am =================================================================== --- src/prelude/Makefile.am (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/prelude/Makefile.am (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -28,13 +28,9 @@ # create forward declarations for gcc builtins -builtins.cf : builtins.c - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E -P $^ | sed -e "/targetm/s/.*//" -e "/_Decimal/s/.*//" -e "s/void (const char \*)0();//" -e "s/\"//g" -e "s/\(__builtin_\) /\1/" > $@ ; \ - fi +builtins.cf : builtins.c prototypes.sed + ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ ; \ - fi + ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ builtins.def : Index: src/prelude/Makefile.in =================================================================== --- src/prelude/Makefile.in (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/prelude/Makefile.in (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -424,13 +424,9 @@ # create forward declarations for gcc builtins -builtins.cf : builtins.c - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E -P $^ | sed -e "/targetm/s/.*//" -e "/_Decimal/s/.*//" -e "s/void (const char \*)0();//" -e "s/\"//g" -e "s/\(__builtin_\) /\1/" > $@ ; \ - fi +builtins.cf : builtins.c prototypes.sed + ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ ; \ - fi + ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ builtins.def : Index: src/prelude/builtins.c =================================================================== --- src/prelude/builtins.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/prelude/builtins.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -3,4 +3,5 @@ #define BT_LAST(NAME) FUNC_SIMPLE(void, NAME) +#define BT_BOOL _Bool #define BT_UINTMAX unsigned long int #define BT_UINT16 short int @@ -22,17 +23,27 @@ #define BT_LONGLONG long long #define BT_LONG long -#define BT_DFLOAT32 _Decimal32 -#define BT_DFLOAT64 _Decimal64 -#define BT_DFLOAT128 _Decimal128 +#define BT_DFLOAT32 __Unsupported +#define BT_DFLOAT64 __Unsupported +#define BT_DFLOAT128 __Unsupported #define BT_DOUBLEPTR double * #define BT_DOUBLE double #define BT_FLOATPTR float * +#define BT_FLOAT128X __Unsupported +#define BT_FLOAT128 __Unsupported +#define BT_FLOAT64X __Unsupported +#define BT_FLOAT64 __Unsupported +#define BT_FLOAT32X __Unsupported +#define BT_FLOAT32 __Unsupported +#define BT_FLOAT16 __Unsupported #define BT_FLOAT float +#define BT_CONST_VPTR const volatile void * #define BT_CONST_PTR const void * #define BT_CONST_STRING const char * +#define BT_CONST_TM_PTR const struct tm * #define BT_PTR_FN_VOID_VAR_PTR_SIZE #define BT_PTR_CONST_STRING char *const #define BT_PTRMODE_PTR #define BT_PTRPTR void ** +#define BT_VPTR volatile void * #define BT_PTR void * #define BT_VOID void @@ -47,169 +58,225 @@ #define BT_SSIZE long int #define BT_PID int - -#define BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_VOID_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR) -#define BT_FN_INT_CONST_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_VOID_VALIST_REF(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF) -#define BT_FN_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_PTR) -#define BT_FN_FLOAT_FLOAT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONGDOUBLE) -#define BT_FN_INT_UINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINT) -#define BT_FN_CONST_STRING(NAME) FUNC_SIMPLE(BT_CONST_STRING, NAME) -#define BT_FN_FLOAT_FLOAT_FLOATPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOATPTR) +#define BT_I16 __int128 +#define BT_I8 long long int +#define BT_I4 int +#define BT_I2 short +#define BT_I1 char + #define BT_FN_INT_INT_INT_INT_INT_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_INT, BT_INT, BT_INT, BT_INT, BT_VAR) -#define BT_FN_INT_INT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) #define BT_FN_INT_LONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONG) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_WORD_WORD_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_WORD, BT_WORD, BT_PTR) #define BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_CONST_PTR) -#define BT_FN_INT_DFLOAT128(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT128) -#define BT_FN_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_FLOAT_CONST_STRING(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_CONST_STRING) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INT(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INT) -#define BT_FN_FLOAT_FLOAT_INT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INT) -#define BT_FN_INT_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGDOUBLE) -#define BT_FN_SIZE_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING, BT_CONST_STRING) +#define BT_FN_VOID_VPTR_I4_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I4, BT_INT) +#define BT_FN_I1_VPTR_I1_INT(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1, BT_INT) +#define BT_FN_INT(NAME) FUNC_SIMPLE(BT_INT, NAME) +#define BT_FN_STRING_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING) +#define BT_FN_PTR_CONST_PTR_SIZE_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_SIZE, BT_VAR) +#define BT_FN_INT_ULONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONGLONG) +#define BT_FN_INT_CONST_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_SIZE) +#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING, BT_PTR_CONST_STRING) +#define BT_FN_STRING_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE) #define BT_FN_VOID_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_SIZE) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME) -#define BT_FN_INT_UINTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINTMAX) -#define BT_FN_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME) -#define BT_FN_INT(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_FLOAT_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_INTPTR) -#define BT_FN_DOUBLE_DOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONGDOUBLE) -#define BT_FN_PTR_CONST_PTR_SIZE_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_SIZE, BT_VAR) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT) -#define BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_STRING_CONST_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_INT) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONG(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONG) -#define BT_FN_COMPLEX_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_VOID(NAME) FUNC_SIMPLE(BT_VOID, NAME) -#define BT_FN_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT) -#define BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_FLOAT, BT_FLOATPTR, BT_FLOATPTR) -#define BT_FN_INT_DFLOAT64(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT64) -#define BT_FN_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INTPTR) -#define BT_FN_WINT_WINT(NAME) FUNC_SIMPLE(BT_WINT, NAME, BT_WINT) -#define BT_FN_LONGLONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGDOUBLE) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE) -#define BT_FN_DFLOAT64_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_CONST_STRING) -#define BT_FN_DOUBLE_DOUBLE_INT(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INT) #define BT_FN_INTMAX_INTMAX(NAME) FUNC_SIMPLE(BT_INTMAX, NAME, BT_INTMAX) -#define BT_FN_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VAR) -#define BT_FN_LONG_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG, BT_LONG) -#define BT_FN_DOUBLE_DOUBLE_LONG(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONG) -#define BT_FN_LONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONGDOUBLE) -#define BT_FN_FLOAT_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_FLOAT) -#define BT_FN_VOID_VALIST_REF_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VAR) -#define BT_FN_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING) +#define BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_SIZE, BT_SIZE, BT_FILEPTR) +#define BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE, BT_SIZE) #define BT_FN_VOID_VALIST_REF_VALIST_ARG(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VALIST_ARG) #define BT_FN_LONGDOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_CONST_STRING) +#define BT_FN_LONGLONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_FLOAT) +#define BT_FN_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME) +#define BT_FN_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGDOUBLE) +#define BT_FN_BOOL_VPTR_I2_I2(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I2, BT_I2) +#define BT_FN_FLOAT_FLOAT_FLOATPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOATPTR) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE) +#define BT_FN_VOID_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_INT) +#define BT_FN_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG) +#define BT_FN_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DOUBLE) +#define BT_FN_BOOL_VPTR_PTR_I16_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I16, BT_BOOL, BT_INT, BT_INT) +#define BT_FN_UINT(NAME) FUNC_SIMPLE(BT_UINT, NAME) +#define BT_FN_DOUBLE_DOUBLE_INT(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INT) +#define BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR, BT_LONGDOUBLEPTR) +#define BT_FN_INT_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VAR) +#define BT_FN_BOOL_INT_INT_INTPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_INT, BT_INT, BT_INTPTR) +#define BT_FN_DFLOAT32_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_DFLOAT32) +#define BT_FN_VOID_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME) +#define BT_FN_INT_CONST_STRING_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_FILEPTR) +#define BT_FN_VOID_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_INT) +#define BT_FN_DFLOAT128_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_CONST_STRING) +#define BT_FN_BOOL_VPTR_I16_I16(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I16, BT_I16) +#define BT_FN_BOOL_LONG_LONG_LONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_LONG, BT_LONG, BT_LONG, BT_PTR) +#define BT_FN_INT_DFLOAT64(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT64) +#define BT_FN_LONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_FLOAT) +#define BT_FN_CONST_STRING(NAME) FUNC_SIMPLE(BT_CONST_STRING, NAME) +#define BT_FN_SIZE_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING, BT_CONST_STRING) +#define BT_FN_COMPLEX_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_FLOAT) +#define BT_FN_VOID_SIZE_VPTR_PTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_PTR, BT_INT) +#define BT_FN_STRING_CONST_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_INT) +#define BT_FN_INT_CONST_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VAR) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_INT(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INT) +#define BT_FN_BOOL_VPTR_I1_I1(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I1, BT_I1) +#define BT_FN_DOUBLE_DOUBLE_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLEPTR) +#define BT_FN_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONG(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONG) +#define BT_FN_I16_VPTR_I16_INT(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16, BT_INT) +#define BT_FN_INT_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VAR) +#define BT_FN_UINT64_UINT64(NAME) FUNC_SIMPLE(BT_UINT64, NAME, BT_UINT64) +#define BT_FN_BOOL_VPTR_PTR_I2_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I2, BT_BOOL, BT_INT, BT_INT) +#define BT_FN_PTR_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE) +#define BT_FN_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_INT) +#define BT_FN_FLOAT_FLOAT_LONG(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONG) +#define BT_FN_FLOAT_CONST_STRING(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_CONST_STRING) +#define BT_FN_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INTPTR) +#define BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE) +#define BT_FN_INT_LONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGLONG) +#define BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE) +#define BT_FN_PTR_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR) +#define BT_FN_I1_VPTR_I1_I1(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1, BT_I1) +#define BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) +#define BT_FN_FLOAT_FLOAT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONGDOUBLE) +#define BT_FN_DOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_CONST_STRING) +#define BT_FN_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME) +#define BT_FN_I16_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_CONST_VPTR, BT_INT) +#define BT_FN_FLOAT_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_FLOAT) +#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) +#define BT_FN_SIZE_CONST_PTR_INT(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_INT) +#define BT_FN_DOUBLE_DOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONGDOUBLE) +#define BT_FN_LONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONGDOUBLE) +#define BT_FN_BOOL_SIZE_CONST_VPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_SIZE, BT_CONST_VPTR) +#define BT_FN_I16_VPTR_I16(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16) +#define BT_FN_VOID_VPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR) +#define BT_FN_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME) +#define BT_FN_VOID_PTRMODE_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTRMODE_PTR) +#define BT_FN_WINT_WINT(NAME) FUNC_SIMPLE(BT_WINT, NAME, BT_WINT) +#define BT_FN_BOOL_VPTR_I8_I8(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I8, BT_I8) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INTPTR) +#define BT_FN_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INTPTR) +#define BT_FN_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_COMPLEX_FLOAT) +#define BT_FN_BOOL_VPTR_PTR_I8_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I8, BT_BOOL, BT_INT, BT_INT) +#define BT_FN_I4_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_CONST_VPTR, BT_INT) +#define BT_FN_INT_WINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_WINT) +#define BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_DOUBLE, BT_DOUBLEPTR, BT_DOUBLEPTR) +#define BT_FN_I8_VPTR_I8_INT(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8, BT_INT) +#define BT_FN_VOID_PTR_WORD_WORD_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_WORD, BT_WORD, BT_PTR) +#define BT_FN_I4_VPTR_I4_I4(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4, BT_I4) +#define BT_FN_PTR_CONST_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_INT, BT_SIZE) +#define BT_FN_INT_UINTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINTMAX) +#define BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_ULONGLONG, BT_ULONGLONG, BT_ULONGLONG, BT_PTR) +#define BT_FN_LONGLONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGDOUBLE) +#define BT_FN_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT) +#define BT_FN_INT_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE, BT_SIZE) +#define BT_FN_INT_DFLOAT128(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT128) +#define BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR_FN_VOID_VAR_PTR_SIZE) +#define BT_FN_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE) +#define BT_FN_DFLOAT32_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_CONST_STRING) +#define BT_FN_LONG_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG, BT_LONG) +#define BT_FN_VOID_VPTR_I8_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I8, BT_INT) +#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) +#define BT_FN_BOOL_VAR(NAME) FUNC_SIMPLE(BT_BOOL, NAME) +#define BT_FN_INT_FILEPTR_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VAR) +#define BT_FN_COMPLEX_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_DOUBLE) +#define BT_FN_INT_ULONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONG) +#define BT_FN_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_SIZE) +#define BT_FN_VOID(NAME) FUNC_SIMPLE(BT_VOID, NAME) +#define BT_FN_INT_DFLOAT32(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT32) +#define BT_FN_VOID_SIZE_CONST_VPTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_CONST_VPTR, BT_PTR, BT_INT) +#define BT_FN_UNWINDWORD_PTR(NAME) FUNC_SIMPLE(BT_UNWINDWORD, NAME, BT_PTR) +#define BT_FN_I1_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_CONST_VPTR, BT_INT) +#define BT_FN_INT_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) +#define BT_FN_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING) +#define BT_FN_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE, BT_SIZE) +#define BT_FN_VOID_VPTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_INT) +#define BT_FN_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME) +#define BT_FN_PTR_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME) +#define BT_FN_I8_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_CONST_VPTR, BT_INT) +#define BT_FN_LONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_DOUBLE) +#define BT_FN_LONGLONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_DOUBLE) +#define BT_FN_BOOL_VPTR_PTR_I4_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I4, BT_BOOL, BT_INT, BT_INT) +#define BT_FN_VOID_CONST_PTR_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_VAR) +#define BT_FN_DOUBLE_DOUBLE_LONG(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONG) +#define BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_INTPTR) +#define BT_FN_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE) +#define BT_FN_INT_PTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTR) #define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE) +#define BT_FN_BOOL_VPTR_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_INT) +#define BT_FN_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_COMPLEX_DOUBLE) +#define BT_FN_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE) +#define BT_FN_I2_VPTR_I2_INT(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2, BT_INT) +#define BT_FN_INT_INT_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_FILEPTR) +#define BT_FN_DFLOAT64_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_DFLOAT64) +#define BT_FN_I8_VPTR_I8(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8) +#define BT_FN_DOUBLE_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_INT, BT_DOUBLE) +#define BT_FN_I16_VPTR_I16_I16(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16, BT_I16) +#define BT_FN_VOID_VPTR_I16_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I16, BT_INT) +#define BT_FN_VOID_VPTR_I1_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I1, BT_INT) +#define BT_FN_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME) +#define BT_FN_FLOAT_INT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_INT, BT_FLOAT) +#define BT_FN_I2_VPTR_I2_I2(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2, BT_I2) +#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE) +#define BT_FN_VOID_VALIST_REF_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VAR) +#define BT_FN_UINT32_UINT32(NAME) FUNC_SIMPLE(BT_UINT32, NAME, BT_UINT32) +#define BT_FN_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT) +#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_CONST_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_PTR, BT_CONST_PTR, BT_SIZE) +#define BT_FN_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME) +#define BT_FN_FLOAT_FLOAT_INT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INT) +#define BT_FN_INT_UINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINT) +#define BT_FN_SIZE_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING) +#define BT_FN_PTR_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE) +#define BT_FN_I2_VPTR_I2(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2) +#define BT_FN_UINT16_UINT16(NAME) FUNC_SIMPLE(BT_UINT16, NAME, BT_UINT16) +#define BT_FN_INT_INTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INTMAX) +#define BT_FN_VOID_PTR_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_PTR) #define BT_FN_STRING_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING) -#define BT_FN_VOID_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_INT) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_INT_ULONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONGLONG) -#define BT_FN_INT_FILEPTR_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VAR) -#define BT_FN_LONGLONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_DOUBLE) -#define BT_FN_INT_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_INT) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_INT_WINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_WINT) -#define BT_FN_PTR_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE) -#define BT_FN_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_INT) +#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE) +#define BT_FN_I2_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_CONST_VPTR, BT_INT) +#define BT_FN_I1_VPTR_I1(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1) +#define BT_FN_LONGLONG_LONGLONG(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGLONG) +#define BT_FN_PID(NAME) FUNC_SIMPLE(BT_PID, NAME) +#define BT_FN_I4_VPTR_I4(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4) +#define BT_FN_I8_VPTR_I8_I8(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8, BT_I8) +#define BT_FN_VOID_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR) +#define BT_FN_VOID_VPTR_I2_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I2, BT_INT) +#define BT_FN_VOID_SIZE_VPTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_INT) +#define BT_FN_VOID_VALIST_REF(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF) +#define BT_FN_INT_PTRPTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTRPTR, BT_SIZE, BT_SIZE) +#define BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING) +#define BT_FN_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VAR) +#define BT_FN_DFLOAT64_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_CONST_STRING) +#define BT_FN_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME) +#define BT_FN_PTR_PTR_INT_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE, BT_SIZE) +#define BT_FN_INT_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING) +#define BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_LONGDOUBLE) +#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR) +#define BT_FN_BOOL_SIZE_VPTR_PTR_PTR_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_PTR, BT_INT, BT_INT) +#define BT_FN_BOOL_UINT_UINT_UINTPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_UINT, BT_UINT, BT_UINT, BT_PTR) +#define BT_FN_BOOL_VPTR_I4_I4(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I4, BT_I4) +#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT) +#define BT_FN_FLOAT_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_INTPTR) +#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE) +#define BT_FN_I4_VPTR_I4_INT(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4, BT_INT) +#define BT_FN_VOID_CONST_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_PTR, BT_SIZE) +#define BT_FN_DFLOAT128_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_DFLOAT128) +#define BT_FN_LONGDOUBLE_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_INT, BT_LONGDOUBLE) +#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME) +#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING) +#define BT_FN_INT_INT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT) +#define BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_FLOAT, BT_FLOATPTR, BT_FLOATPTR) #define BT_FN_INT_FLOAT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FLOAT) -#define BT_FN_DOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_CONST_STRING) -#define BT_FN_LONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_FLOAT) -#define BT_FN_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE, BT_SIZE) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_LONGLONG_LONGLONG(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGLONG) -#define BT_FN_PTR_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE, BT_SIZE) -#define BT_FN_FLOAT_FLOAT_LONG(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONG) +#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) +#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VAR) +#define BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_SSIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) +#define BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_LONGLONG, BT_LONGLONG, BT_LONGLONG, BT_PTR) +#define BT_FN_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_SIZE) +#define BT_FN_PTR_UINT(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_UINT) #define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_SIZE) -#define BT_FN_PTR_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_SIZE_CONST_PTR_INT(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_INT) -#define BT_FN_INT_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE, BT_SIZE) -#define BT_FN_PTR_UINT(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_UINT) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_DFLOAT128_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_CONST_STRING) -#define BT_FN_DOUBLE_DOUBLE_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLEPTR) -#define BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_SSIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_DFLOAT32_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_DFLOAT32) -#define BT_FN_INT_PTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTR) -#define BT_FN_UINT32_UINT32(NAME) FUNC_SIMPLE(BT_UINT32, NAME, BT_UINT32) -#define BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR_FN_VOID_VAR_PTR_SIZE) -#define BT_FN_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DOUBLE) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_INT_ULONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONG) -#define BT_FN_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INTPTR) -#define BT_FN_UINT64_UINT64(NAME) FUNC_SIMPLE(BT_UINT64, NAME, BT_UINT64) -#define BT_FN_STRING_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_INT_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_PTR_PTR_INT_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE, BT_SIZE) -#define BT_FN_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_VOID_CONST_PTR_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_VAR) -#define BT_FN_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_INT_PTRPTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTRPTR, BT_SIZE, BT_SIZE) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_INT_DFLOAT32(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT32) -#define BT_FN_DFLOAT64_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_DFLOAT64) -#define BT_FN_VOID_CONST_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_PTR, BT_SIZE) -#define BT_FN_UNWINDWORD_PTR(NAME) FUNC_SIMPLE(BT_UNWINDWORD, NAME, BT_PTR) -#define BT_FN_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT) -#define BT_FN_COMPLEX_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_FLOAT) -#define BT_FN_UINT(NAME) FUNC_SIMPLE(BT_UINT, NAME) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_INTPTR) -#define BT_FN_UINT16_UINT16(NAME) FUNC_SIMPLE(BT_UINT16, NAME, BT_UINT16) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_FLOAT_INT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_INT, BT_FLOAT) -#define BT_FN_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_SIZE, BT_SIZE, BT_FILEPTR) -#define BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_DOUBLE, BT_DOUBLEPTR, BT_DOUBLEPTR) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE) -#define BT_FN_LONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_DOUBLE) -#define BT_FN_SIZE_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING) -#define BT_FN_LONGLONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_FLOAT) -#define BT_FN_INT_CONST_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME) -#define BT_FN_PID(NAME) FUNC_SIMPLE(BT_PID, NAME) -#define BT_FN_INT_CONST_STRING_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_FILEPTR) -#define BT_FN_INT_LONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGLONG) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_INT_INT_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_FILEPTR) -#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_VOID_PTRMODE_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTRMODE_PTR) -#define BT_FN_INT_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_DFLOAT32_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_CONST_STRING) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_SIZE) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_DFLOAT128_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_DFLOAT128) -#define BT_FN_DOUBLE_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_INT, BT_DOUBLE) -#define BT_FN_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME) -#define BT_FN_LONGDOUBLE_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_INT, BT_LONGDOUBLE) -#define BT_FN_PTR_CONST_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_INT, BT_SIZE) -#define BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR, BT_LONGDOUBLEPTR) -#define BT_FN_INT_INTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INTMAX) -#define BT_FN_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR) +#define BT_FN_BOOL_VPTR_PTR_I1_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I1, BT_BOOL, BT_INT, BT_INT) +#define BT_FN_BOOL_ULONG_ULONG_ULONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_ULONG, BT_ULONG, BT_ULONG, BT_PTR) #include "builtins.def" Index: src/prelude/builtins.def =================================================================== --- src/prelude/builtins.def (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/prelude/builtins.def (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -1,5 +1,5 @@ /* This file contains the definitions and documentation for the builtins used in the GNU compiler. - Copyright (C) 2000-2014 Free Software Foundation, Inc. + Copyright (C) 2000-2016 Free Software Foundation, Inc. This file is part of GCC. @@ -63,4 +63,14 @@ The builtins is registered only if COND is true. */ + +/* A macro for builtins where the + BUILT_IN_*_CHKP = BUILT_IN_* + BEGIN_CHKP_BUILTINS + 1 + enums should be defined too. */ +#ifndef DEF_BUILTIN_CHKP +#define DEF_BUILTIN_CHKP(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, \ + FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) \ + DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \ + NONANSI_P, ATTRS, IMPLICIT, COND) +#endif /* A GCC builtin (like __builtin_saveregs) is provided by the @@ -88,4 +98,8 @@ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ true, true, false, ATTRS, true, true) +#undef DEF_LIB_BUILTIN_CHKP +#define DEF_LIB_BUILTIN_CHKP(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \ + TYPE, true, true, false, ATTRS, true, true) /* Like DEF_LIB_BUILTIN, except that the function is not one that is @@ -97,4 +111,8 @@ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ true, true, true, ATTRS, false, true) +#undef DEF_EXT_LIB_BUILTIN_CHKP +#define DEF_EXT_LIB_BUILTIN_CHKP(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \ + TYPE, true, true, true, ATTRS, false, true) /* Like DEF_LIB_BUILTIN, except that the function is only a part of @@ -111,4 +129,11 @@ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ true, true, !flag_isoc99, ATTRS, targetm.libc_has_function (function_c99_misc), true) + +/* Like DEF_LIB_BUILTIN, except that the function is only a part of + the standard in C11 or above. */ +#undef DEF_C11_BUILTIN +#define DEF_C11_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, !flag_isoc11, ATTRS, targetm.libc_has_function (function_c11_misc), true) /* Like DEF_C99_BUILTIN, but for complex math functions. */ @@ -140,11 +165,27 @@ false, ATTR_LAST, false, false) -/* Builtin used by the implementation of GNU OpenMP. None of these are - actually implemented in the compiler; they're all in libgomp. */ +/* Builtin used by the implementation of OpenACC and OpenMP. Few of these are + actually implemented in the compiler; most are in libgomp. */ +/* These builtins also need to be enabled in offloading compilers invoked from + mkoffload; for that purpose, we're checking the -foffload-abi flag here. */ +#undef DEF_GOACC_BUILTIN +#define DEF_GOACC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + false, true, true, ATTRS, false, \ + (flag_openacc \ + || flag_offload_abi != OFFLOAD_ABI_UNSET)) +#undef DEF_GOACC_BUILTIN_COMPILER +#define DEF_GOACC_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + flag_openacc, true, true, ATTRS, false, true) #undef DEF_GOMP_BUILTIN #define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ false, true, true, ATTRS, false, \ - (flag_openmp || flag_tree_parallelize_loops)) + (flag_openacc \ + || flag_openmp \ + || flag_tree_parallelize_loops > 1 \ + || flag_cilkplus \ + || flag_offload_abi != OFFLOAD_ABI_UNSET)) /* Builtin used by implementation of Cilk Plus. Most of these are decomposed @@ -170,5 +211,6 @@ true, true, true, ATTRS, true, \ (flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_THREAD \ - | SANITIZE_UNDEFINED))) + | SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT) \ + || flag_sanitize_coverage)) #undef DEF_CILKPLUS_BUILTIN @@ -176,4 +218,10 @@ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \ false, false, false, ATTRS, false, flag_cilkplus) + +/* Builtin used by the implementation of Pointer Bounds Checker. */ +#undef DEF_CHKP_BUILTIN +#define DEF_CHKP_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \ + TYPE, true, true, false, ATTRS, true, true) /* Define an attribute list for math functions that are normally @@ -224,4 +272,5 @@ DEF_C99_BUILTIN (BUILT_IN_ACOSHL, "acoshl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_C99_C90RES_BUILTIN (BUILT_IN_ACOSL, "acosl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C11_BUILTIN (BUILT_IN_ALIGNED_ALLOC, "aligned_alloc", BT_FN_PTR_SIZE_SIZE, ATTR_MALLOC_NOTHROW_LIST) DEF_LIB_BUILTIN (BUILT_IN_ASIN, "asin", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_C99_C90RES_BUILTIN (BUILT_IN_ASINF, "asinf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) @@ -428,7 +477,7 @@ DEF_C99_BUILTIN (BUILT_IN_REMQUOF, "remquof", BT_FN_FLOAT_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) DEF_C99_BUILTIN (BUILT_IN_REMQUOL, "remquol", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) -DEF_C99_BUILTIN (BUILT_IN_RINT, "rint", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) -DEF_C99_BUILTIN (BUILT_IN_RINTF, "rintf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) -DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_RINT, "rint", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_RINTF, "rintf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) DEF_C99_BUILTIN (BUILT_IN_ROUND, "round", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_ROUNDF, "roundf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) @@ -443,5 +492,5 @@ DEF_C99_BUILTIN (BUILT_IN_SCALBNF, "scalbnf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_C99_BUILTIN (BUILT_IN_SCALBNL, "scalbnl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO) -DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBIT, "signbit", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBIT, "signbit", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITF, "signbitf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITL, "signbitl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) @@ -569,20 +618,20 @@ DEF_LIB_BUILTIN (BUILT_IN_MEMCHR, "memchr", BT_FN_PTR_CONST_PTR_INT_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) DEF_LIB_BUILTIN (BUILT_IN_MEMCMP, "memcmp", BT_FN_INT_CONST_PTR_CONST_PTR_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_MEMCPY, "memcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_MEMMOVE, "memmove", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY, "mempcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_MEMSET, "memset", BT_FN_PTR_PTR_INT_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMCPY, "memcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMMOVE, "memmove", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMPCPY, "mempcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMSET, "memset", BT_FN_PTR_PTR_INT_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_RINDEX, "rindex", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_STPCPY, "stpcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STPCPY, "stpcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STPNCPY, "stpncpy", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCASECMP, "strcasecmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_STRCAT, "strcat", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_STRCHR, "strchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCAT, "strcat", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCHR, "strchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) DEF_LIB_BUILTIN (BUILT_IN_STRCMP, "strcmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_STRCPY, "strcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCPY, "strcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_RET1_NOTHROW_NONNULL_LEAF) DEF_LIB_BUILTIN (BUILT_IN_STRCSPN, "strcspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRDUP, "strdup", BT_FN_STRING_CONST_STRING, ATTR_MALLOC_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNDUP, "strndup", BT_FN_STRING_CONST_STRING_SIZE, ATTR_MALLOC_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_STRLEN, "strlen", BT_FN_SIZE_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRLEN, "strlen", BT_FN_SIZE_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCASECMP, "strncasecmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) DEF_LIB_BUILTIN (BUILT_IN_STRNCAT, "strncat", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) @@ -658,6 +707,30 @@ DEF_C94_BUILTIN (BUILT_IN_TOWUPPER, "towupper", BT_FN_WINT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +/* Category: integer overflow checking builtins. */ +DEF_GCC_BUILTIN (BUILT_IN_ADD_OVERFLOW, "add_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_SUB_OVERFLOW, "sub_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_MUL_OVERFLOW, "mul_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF) +/* Clang compatibility. */ +DEF_GCC_BUILTIN (BUILT_IN_SADD_OVERFLOW, "sadd_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SADDL_OVERFLOW, "saddl_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SADDLL_OVERFLOW, "saddll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SSUB_OVERFLOW, "ssub_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SSUBL_OVERFLOW, "ssubl_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SSUBLL_OVERFLOW, "ssubll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SMUL_OVERFLOW, "smul_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SMULL_OVERFLOW, "smull_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SMULLL_OVERFLOW, "smulll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UADD_OVERFLOW, "uadd_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UADDL_OVERFLOW, "uaddl_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UADDLL_OVERFLOW, "uaddll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_USUB_OVERFLOW, "usub_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_USUBL_OVERFLOW, "usubl_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_USUBLL_OVERFLOW, "usubll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UMUL_OVERFLOW, "umul_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UMULL_OVERFLOW, "umull_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UMULLL_OVERFLOW, "umulll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) + /* Category: miscellaneous builtins. */ -DEF_LIB_BUILTIN (BUILT_IN_ABORT, "abort", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ABORT, "abort", BT_FN_VOID, ATTR_TMPURE_NORETURN_NOTHROW_LEAF_LIST) DEF_LIB_BUILTIN (BUILT_IN_ABS, "abs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_AGGREGATE_INCOMING_ADDRESS, "aggregate_incoming_address", BT_FN_PTR_VAR, ATTR_LEAF_LIST) @@ -794,12 +867,12 @@ /* Object size checking builtins. */ DEF_GCC_BUILTIN (BUILT_IN_OBJECT_SIZE, "object_size", BT_FN_SIZE_CONST_PTR_INT, ATTR_PURE_NOTHROW_LEAF_LIST) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMCPY_CHK, "__memcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMMOVE_CHK, "__memmove_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY_CHK, "__mempcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMSET_CHK, "__memset_chk", BT_FN_PTR_PTR_INT_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_STPCPY_CHK, "__stpcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMCPY_CHK, "__memcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMMOVE_CHK, "__memmove_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMPCPY_CHK, "__mempcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMSET_CHK, "__memset_chk", BT_FN_PTR_PTR_INT_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STPCPY_CHK, "__stpcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STPNCPY_CHK, "__stpncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCAT_CHK, "__strcat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCPY_CHK, "__strcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STRCAT_CHK, "__strcat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STRCPY_CHK, "__strcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCAT_CHK, "__strncat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCPY_CHK, "__strncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) @@ -854,9 +927,9 @@ DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST) -#if 0 /* Synchronization Primitives. */ #include "sync-builtins.def" -/* OpenMP builtins. */ +#if 0 +/* Offloading and Multi Processing builtins. */ #include "omp-builtins.def" @@ -872,3 +945,9 @@ /* Cilk Plus builtins. */ #include "cilkplus.def" + +/* Pointer Bounds Checker builtins. */ +#include "chkp-builtins.def" #endif + +#undef DEF_BUILTIN_CHKP +#undef DEF_BUILTIN Index: src/prelude/prototypes.awk =================================================================== --- src/prelude/prototypes.awk (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/prelude/prototypes.awk (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -17,54 +17,77 @@ BEGIN { - FS = "(" + FS = "[( )]" # order so string search is longest string - types[0] = "UINTMAX"; vtypes[0] = "unsigned long int" - types[1] = "UINT16"; vtypes[1] = "short int" - types[2] = "UINT32"; vtypes[2] = "int" - types[3] = "UINT64"; vtypes[3] = "long long int" - types[4] = "UINT"; vtypes[4] = "unsigned int" - types[5] = "INTMAX"; vtypes[5] = "long int" - types[6] = "INTPTR"; vtypes[6] = "int *" - types[7] = "WINT"; vtypes[7] = "unsigned int" - types[8] = "INT"; vtypes[8] = "int" - types[9] = "ULONGLONG"; vtypes[9] = "unsigned long long" - types[10] = "ULONG"; vtypes[10] = "unsigned long" - types[11] = "UNSIGNED"; vtypes[11] = "unsigned" - types[12] = "COMPLEX_LONGDOUBLE"; vtypes[12] = "_Complex long double" - types[13] = "COMPLEX_DOUBLE"; vtypes[13] = "_Complex double" - types[14] = "COMPLEX_FLOAT"; vtypes[14] = "_Complex float" - types[15] = "LONGDOUBLEPTR"; vtypes[15] = "long double *" - types[16] = "LONGDOUBLE"; vtypes[16] = "long double" - types[17] = "LONGLONG"; vtypes[17] = "long long" - types[18] = "LONG"; vtypes[18] = "long" - types[19] = "DFLOAT32"; vtypes[19] = "_Decimal32" - types[20] = "DFLOAT64"; vtypes[20] = "_Decimal64" - types[21] = "DFLOAT128"; vtypes[21] = "_Decimal128" - types[22] = "DOUBLEPTR"; vtypes[22] = "double *" - types[23] = "DOUBLE"; vtypes[23] = "double" - types[24] = "FLOATPTR"; vtypes[24] = "float *" - types[25] = "FLOAT"; vtypes[25] = "float" - types[26] = "CONST_PTR"; vtypes[26] = "const void *" - types[27] = "CONST_STRING"; vtypes[27] = "const char *" - types[28] = "PTR_FN_VOID_VAR_PTR_SIZE"; vtypes[28] = "" - types[29] = "PTR_CONST_STRING"; vtypes[29] = "char *const" - types[30] = "PTRMODE_PTR"; vtypes[30] = "" - types[31] = "PTRPTR"; vtypes[31] = "void **" - types[32] = "PTR"; vtypes[32] = "void *" - types[33] = "VOID"; vtypes[33] = "void" - types[34] = "STRING"; vtypes[34] = "char *" - types[35] = "FILEPTR"; vtypes[35] = "struct _IO_FILE *" - types[36] = "SIZE"; vtypes[36] = "unsigned long" - types[37] = "VAR"; vtypes[37] = "..." - types[38] = "VALIST_ARG"; vtypes[38] = "__builtin_va_list" - types[39] = "VALIST_REF"; vtypes[39] = "__builtin_va_list" - types[40] = "UNWINDWORD"; vtypes[40] = "void *" - types[41] = "WORD"; vtypes[41] = "" - types[42] = "SSIZE"; vtypes[42] = "long int" - types[43] = "PID"; vtypes[43] = "int" - N = 44 + i=-1 + types[i+=1] = "BOOL"; vtypes[i] = "_Bool" + types[i+=1] = "UINTMAX"; vtypes[i] = "unsigned long int" + types[i+=1] = "UINT16"; vtypes[i] = "short int" + types[i+=1] = "UINT32"; vtypes[i] = "int" + types[i+=1] = "UINT64"; vtypes[i] = "long long int" + types[i+=1] = "UINT"; vtypes[i] = "unsigned int" + types[i+=1] = "INTMAX"; vtypes[i] = "long int" + types[i+=1] = "INTPTR"; vtypes[i] = "int *" + types[i+=1] = "WINT"; vtypes[i] = "unsigned int" + types[i+=1] = "INT"; vtypes[i] = "int" + types[i+=1] = "ULONGLONG"; vtypes[i] = "unsigned long long" + types[i+=1] = "ULONG"; vtypes[i] = "unsigned long" + types[i+=1] = "UNSIGNED"; vtypes[i] = "unsigned" + types[i+=1] = "COMPLEX_LONGDOUBLE"; vtypes[i] = "_Complex long double" + types[i+=1] = "COMPLEX_DOUBLE"; vtypes[i] = "_Complex double" + types[i+=1] = "COMPLEX_FLOAT"; vtypes[i] = "_Complex float" + types[i+=1] = "LONGDOUBLEPTR"; vtypes[i] = "long double *" + types[i+=1] = "LONGDOUBLE"; vtypes[i] = "long double" + types[i+=1] = "LONGLONG"; vtypes[i] = "long long" + types[i+=1] = "LONG"; vtypes[i] = "long" + types[i+=1] = "DFLOAT32"; vtypes[i] = "__Unsupported" + types[i+=1] = "DFLOAT64"; vtypes[i] = "__Unsupported" + types[i+=1] = "DFLOAT128"; vtypes[i] = "__Unsupported" + types[i+=1] = "DOUBLEPTR"; vtypes[i] = "double *" + types[i+=1] = "DOUBLE"; vtypes[i] = "double" + types[i+=1] = "FLOATPTR"; vtypes[i] = "float *" + types[i+=1] = "FLOAT128X"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT128"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT64X"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT64"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT32X"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT32"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT16"; vtypes[i] = "__Unsupported" + types[i+=1] = "FLOAT"; vtypes[i] = "float" + types[i+=1] = "CONST_VPTR"; vtypes[i] = "const volatile void *" + types[i+=1] = "CONST_PTR"; vtypes[i] = "const void *" + types[i+=1] = "CONST_STRING"; vtypes[i] = "const char *" + types[i+=1] = "CONST_TM_PTR"; vtypes[i] = "const struct tm *" + types[i+=1] = "PTR_FN_VOID_VAR_PTR_SIZE"; vtypes[i] = "" + types[i+=1] = "PTR_CONST_STRING"; vtypes[i] = "char *const" + types[i+=1] = "PTRMODE_PTR"; vtypes[i] = "" + types[i+=1] = "PTRPTR"; vtypes[i] = "void **" + types[i+=1] = "VPTR"; vtypes[i] = "volatile void *" + types[i+=1] = "PTR"; vtypes[i] = "void *" + types[i+=1] = "VOID"; vtypes[i] = "void" + types[i+=1] = "STRING"; vtypes[i] = "char *" + types[i+=1] = "FILEPTR"; vtypes[i] = "struct _IO_FILE *" + types[i+=1] = "SIZE"; vtypes[i] = "unsigned long" + types[i+=1] = "VAR"; vtypes[i] = "..." + types[i+=1] = "VALIST_ARG"; vtypes[i] = "__builtin_va_list" + types[i+=1] = "VALIST_REF"; vtypes[i] = "__builtin_va_list" + types[i+=1] = "UNWINDWORD"; vtypes[i] = "void *" + types[i+=1] = "WORD"; vtypes[i] = "" + types[i+=1] = "SSIZE"; vtypes[i] = "long int" + types[i+=1] = "PID"; vtypes[i] = "int" + types[i+=1] = "I16"; vtypes[i] = "__int128" + types[i+=1] = "I8"; vtypes[i] = "long long int" + types[i+=1] = "I4"; vtypes[i] = "int" + types[i+=1] = "I2"; vtypes[i] = "short" + types[i+=1] = "I1"; vtypes[i] = "char" + N = i + 1 } # BEGIN -/^BT_/ { prototypes[$1] = $1 } +/BT_FN/ { + for (i = 1; i <= NF; i++) { + if( match($i, "BT_FN") != 0 ) { + prototypes[$i] = $i + } + } + } END { @@ -80,46 +103,47 @@ for ( prototype in prototypes ) { - if ( index( "BT_LAST", prototype ) == 1 ) { - continue - } # if + # printf( "//\"%s\"\n", prototype ) + if ( index( "BT_LAST", prototype ) == 1 ) { + continue + } # if - printf( "#define %s(NAME) FUNC_SIMPLE(", prototype ) + printf( "#define %s(NAME) FUNC_SIMPLE(", prototype ) - if ( sub( "BT_FN_", "", prototype ) == 0 ) { - printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype ) - exit 0 - } # if + if ( sub( "BT_FN_", "", prototype ) == 0 ) { + printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype ) + exit 0 + } # if - # generate function return type as macro - for ( t = 0; t < N; t += 1 ) { # find longest match - type = types[t]; - if ( index( prototype, type ) == 1 ) { # found match - printf( "BT_%s, NAME", type ) - sub( type, "", prototype ) - break; - } # if - } # for + # generate function return type as macro + for ( t = 0; t < N; t += 1 ) { # find longest match + type = types[t]; + if ( index( prototype, type ) == 1 ) { # found match + printf( "BT_%s, NAME", type ) + sub( type, "", prototype ) + break; + } # if + } # for - # generate function parameter types as macro - if ( index( prototype, "VAR" ) != 2 ) { # C-style empty parameters ? - for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed - sub( "_", "", prototype) # remove "_" - printf( ", ", type ) - temp = prototype - for ( t = 0; t < N; t += 1 ) { # find longest match - type = types[t]; - if ( index( prototype, type ) == 1 ) { # found match - printf( "BT_%s", type ) - sub( type, "", prototype ) - break; - } # if - } # for - if ( temp == prototype ) { # no match found for parameter in macro table - printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype ) - exit 0 - } # if - } # for - } # if - printf( ")\n" ) + # generate function parameter types as macro + if ( index( prototype, "VAR" ) != 2 ) { # C-style empty parameters ? + for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed + sub( "_", "", prototype) # remove "_" + printf( ", ", type ) + temp = prototype + for ( t = 0; t < N; t += 1 ) { # find longest match + type = types[t]; + if ( index( prototype, type ) == 1 ) { # found match + printf( "BT_%s", type ) + sub( type, "", prototype ) + break; + } # if + } # for + if ( temp == prototype ) { # no match found for parameter in macro table + printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype ) + exit 0 + } # if + } # for + } # if + printf( ")\n" ) } # for Index: src/prelude/prototypes.sed =================================================================== --- src/prelude/prototypes.sed (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/prelude/prototypes.sed (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,6 @@ +s/; /;\n/g #Make multi declaration lines into multiple lines +/targetm/s/.*// #Remove targetm declarations +/__Unsupported/s/.*// #Remove Unsupported types declarations +s/void (const char \*)0();// #Remove void (const char \*)0(); +s/\"//g #Remove extraenous quotes in declarations +/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations Index: src/prelude/sync-builtins.def =================================================================== --- src/prelude/sync-builtins.def (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/prelude/sync-builtins.def (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,614 @@ +/* This file contains the definitions and documentation for the + synchronization builtins used in the GNU compiler. + Copyright (C) 2005-2016 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +/* Before including this file, you should define a macro: + + DEF_SYNC_BUILTIN (ENUM, NAME, TYPE, ATTRS) + + See builtins.def for details. */ + +/* Synchronization Primitives. The "_N" version is the one that the user + is supposed to be using. It's overloaded, and is resolved to one of the + "_1" through "_16" versions, plus some extra casts. */ + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_N, "__sync_fetch_and_add", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_1, "__sync_fetch_and_add_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_2, "__sync_fetch_and_add_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_4, "__sync_fetch_and_add_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_8, "__sync_fetch_and_add_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_16, "__sync_fetch_and_add_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_N, "__sync_fetch_and_sub", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_1, "__sync_fetch_and_sub_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_2, "__sync_fetch_and_sub_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_4, "__sync_fetch_and_sub_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_8, "__sync_fetch_and_sub_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_16, "__sync_fetch_and_sub_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_N, "__sync_fetch_and_or", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_1, "__sync_fetch_and_or_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_2, "__sync_fetch_and_or_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_4, "__sync_fetch_and_or_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_8, "__sync_fetch_and_or_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_16, "__sync_fetch_and_or_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_N, "__sync_fetch_and_and", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_1, "__sync_fetch_and_and_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_2, "__sync_fetch_and_and_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_4, "__sync_fetch_and_and_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_8, "__sync_fetch_and_and_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_16, "__sync_fetch_and_and_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_N, "__sync_fetch_and_xor", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_1, "__sync_fetch_and_xor_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_2, "__sync_fetch_and_xor_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_4, "__sync_fetch_and_xor_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_8, "__sync_fetch_and_xor_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_16, "__sync_fetch_and_xor_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_N, "__sync_fetch_and_nand", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_1, "__sync_fetch_and_nand_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_2, "__sync_fetch_and_nand_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_4, "__sync_fetch_and_nand_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_8, "__sync_fetch_and_nand_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_16, "__sync_fetch_and_nand_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_N, "__sync_add_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_1, "__sync_add_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_2, "__sync_add_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_4, "__sync_add_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_8, "__sync_add_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_16, "__sync_add_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_N, "__sync_sub_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_1, "__sync_sub_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_2, "__sync_sub_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_4, "__sync_sub_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_8, "__sync_sub_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_16, "__sync_sub_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_N, "__sync_or_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_1, "__sync_or_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_2, "__sync_or_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_4, "__sync_or_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_8, "__sync_or_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_16, "__sync_or_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_N, "__sync_and_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_1, "__sync_and_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_2, "__sync_and_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_4, "__sync_and_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_8, "__sync_and_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_16, "__sync_and_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_N, "__sync_xor_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_1, "__sync_xor_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_2, "__sync_xor_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_4, "__sync_xor_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_8, "__sync_xor_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_16, "__sync_xor_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_N, "__sync_nand_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_1, "__sync_nand_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_2, "__sync_nand_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_4, "__sync_nand_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_8, "__sync_nand_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_16, "__sync_nand_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N, + "__sync_bool_compare_and_swap", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1, + "__sync_bool_compare_and_swap_1", + BT_FN_BOOL_VPTR_I1_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2, + "__sync_bool_compare_and_swap_2", + BT_FN_BOOL_VPTR_I2_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4, + "__sync_bool_compare_and_swap_4", + BT_FN_BOOL_VPTR_I4_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8, + "__sync_bool_compare_and_swap_8", + BT_FN_BOOL_VPTR_I8_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16, + "__sync_bool_compare_and_swap_16", + BT_FN_BOOL_VPTR_I16_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N, + "__sync_val_compare_and_swap", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1, + "__sync_val_compare_and_swap_1", + BT_FN_I1_VPTR_I1_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2, + "__sync_val_compare_and_swap_2", + BT_FN_I2_VPTR_I2_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4, + "__sync_val_compare_and_swap_4", + BT_FN_I4_VPTR_I4_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8, + "__sync_val_compare_and_swap_8", + BT_FN_I8_VPTR_I8_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16, + "__sync_val_compare_and_swap_16", + BT_FN_I16_VPTR_I16_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_N, + "__sync_lock_test_and_set", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_1, + "__sync_lock_test_and_set_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_2, + "__sync_lock_test_and_set_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_4, + "__sync_lock_test_and_set_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_8, + "__sync_lock_test_and_set_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_16, + "__sync_lock_test_and_set_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_N, "__sync_lock_release", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_1, "__sync_lock_release_1", + BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_2, "__sync_lock_release_2", + BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_4, "__sync_lock_release_4", + BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_8, "__sync_lock_release_8", + BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_16, "__sync_lock_release_16", + BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SYNCHRONIZE, "__sync_synchronize", + BT_FN_VOID, ATTR_NOTHROWCALL_LEAF_LIST) + +/* __sync* builtins for the C++ memory model. */ + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_TEST_AND_SET, "__atomic_test_and_set", + BT_FN_BOOL_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_CLEAR, "__atomic_clear", BT_FN_VOID_VPTR_INT, + ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE, + "__atomic_exchange", + BT_FN_VOID_SIZE_VPTR_PTR_PTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_N, + "__atomic_exchange_n", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_1, + "__atomic_exchange_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_2, + "__atomic_exchange_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_4, + "__atomic_exchange_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_8, + "__atomic_exchange_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_16, + "__atomic_exchange_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD, + "__atomic_load", + BT_FN_VOID_SIZE_CONST_VPTR_PTR_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_N, + "__atomic_load_n", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_1, + "__atomic_load_1", + BT_FN_I1_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_2, + "__atomic_load_2", + BT_FN_I2_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_4, + "__atomic_load_4", + BT_FN_I4_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_8, + "__atomic_load_8", + BT_FN_I8_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_16, + "__atomic_load_16", + BT_FN_I16_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE, + "__atomic_compare_exchange", + BT_FN_BOOL_SIZE_VPTR_PTR_PTR_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N, + "__atomic_compare_exchange_n", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1, + "__atomic_compare_exchange_1", + BT_FN_BOOL_VPTR_PTR_I1_BOOL_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2, + "__atomic_compare_exchange_2", + BT_FN_BOOL_VPTR_PTR_I2_BOOL_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4, + "__atomic_compare_exchange_4", + BT_FN_BOOL_VPTR_PTR_I4_BOOL_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8, + "__atomic_compare_exchange_8", + BT_FN_BOOL_VPTR_PTR_I8_BOOL_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16, + "__atomic_compare_exchange_16", + BT_FN_BOOL_VPTR_PTR_I16_BOOL_INT_INT, + ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE, + "__atomic_store", + BT_FN_VOID_SIZE_VPTR_PTR_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_N, + "__atomic_store_n", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_1, + "__atomic_store_1", + BT_FN_VOID_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_2, + "__atomic_store_2", + BT_FN_VOID_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_4, + "__atomic_store_4", + BT_FN_VOID_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_8, + "__atomic_store_8", + BT_FN_VOID_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_16, + "__atomic_store_16", + BT_FN_VOID_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_N, + "__atomic_add_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_1, + "__atomic_add_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_2, + "__atomic_add_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_4, + "__atomic_add_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_8, + "__atomic_add_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_16, + "__atomic_add_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_N, + "__atomic_sub_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_1, + "__atomic_sub_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_2, + "__atomic_sub_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_4, + "__atomic_sub_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_8, + "__atomic_sub_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_16, + "__atomic_sub_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_N, + "__atomic_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_1, + "__atomic_and_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_2, + "__atomic_and_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_4, + "__atomic_and_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_8, + "__atomic_and_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_16, + "__atomic_and_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_N, + "__atomic_nand_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_1, + "__atomic_nand_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_2, + "__atomic_nand_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_4, + "__atomic_nand_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_8, + "__atomic_nand_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_16, + "__atomic_nand_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_N, + "__atomic_xor_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_1, + "__atomic_xor_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_2, + "__atomic_xor_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_4, + "__atomic_xor_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_8, + "__atomic_xor_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_16, + "__atomic_xor_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_N, + "__atomic_or_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_1, + "__atomic_or_fetch_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_2, + "__atomic_or_fetch_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_4, + "__atomic_or_fetch_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_8, + "__atomic_or_fetch_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_16, + "__atomic_or_fetch_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_N, + "__atomic_fetch_add", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_1, + "__atomic_fetch_add_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_2, + "__atomic_fetch_add_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_4, + "__atomic_fetch_add_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_8, + "__atomic_fetch_add_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_16, + "__atomic_fetch_add_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_N, + "__atomic_fetch_sub", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_1, + "__atomic_fetch_sub_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_2, + "__atomic_fetch_sub_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_4, + "__atomic_fetch_sub_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_8, + "__atomic_fetch_sub_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_16, + "__atomic_fetch_sub_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_N, + "__atomic_fetch_and", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_1, + "__atomic_fetch_and_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_2, + "__atomic_fetch_and_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_4, + "__atomic_fetch_and_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_8, + "__atomic_fetch_and_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_16, + "__atomic_fetch_and_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_N, + "__atomic_fetch_nand", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_1, + "__atomic_fetch_nand_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_2, + "__atomic_fetch_nand_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_4, + "__atomic_fetch_nand_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_8, + "__atomic_fetch_nand_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_16, + "__atomic_fetch_nand_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_N, + "__atomic_fetch_xor", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_1, + "__atomic_fetch_xor_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_2, + "__atomic_fetch_xor_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_4, + "__atomic_fetch_xor_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_8, + "__atomic_fetch_xor_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_16, + "__atomic_fetch_xor_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_N, + "__atomic_fetch_or", + BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_1, + "__atomic_fetch_or_1", + BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_2, + "__atomic_fetch_or_2", + BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_4, + "__atomic_fetch_or_4", + BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_8, + "__atomic_fetch_or_8", + BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_16, + "__atomic_fetch_or_16", + BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE, + "__atomic_always_lock_free", + BT_FN_BOOL_SIZE_CONST_VPTR, ATTR_CONST_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_IS_LOCK_FREE, + "__atomic_is_lock_free", + BT_FN_BOOL_SIZE_CONST_VPTR, ATTR_CONST_NOTHROW_LEAF_LIST) + + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_THREAD_FENCE, + "__atomic_thread_fence", + BT_FN_VOID_INT, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SIGNAL_FENCE, + "__atomic_signal_fence", + BT_FN_VOID_INT, ATTR_NOTHROW_LEAF_LIST) + +/* This one is actually a function in libatomic and not expected to be + inlined, declared here for convenience of targets generating calls + to it. */ +DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FERAISEEXCEPT, + "__atomic_feraiseexcept", + BT_FN_VOID_INT, ATTR_LEAF_LIST) Index: src/tests/.expect/thread.txt =================================================================== --- src/tests/.expect/thread.txt (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/tests/.expect/thread.txt (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,22 @@ +User main begin +First : Suspend No. 1 +First : Suspend No. 2 +First : Suspend No. 3 +First : Suspend No. 4 +First : Suspend No. 5 +First : Suspend No. 6 +First : Suspend No. 7 +First : Suspend No. 8 +First : Suspend No. 9 +First : Suspend No. 10 +Second : Suspend No. 1 +Second : Suspend No. 2 +Second : Suspend No. 3 +Second : Suspend No. 4 +Second : Suspend No. 5 +Second : Suspend No. 6 +Second : Suspend No. 7 +Second : Suspend No. 8 +Second : Suspend No. 9 +Second : Suspend No. 10 +User main end Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/tests/Makefile.am (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -30,5 +30,5 @@ all-local : - @+python test.py vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once coroutine + @+python test.py vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once coroutine thread all-tests : Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/tests/Makefile.in (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -651,5 +651,5 @@ all-local : - @+python test.py vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once coroutine + @+python test.py vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once coroutine thread all-tests : Index: src/tests/dtor-early-exit.c =================================================================== --- src/tests/dtor-early-exit.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/tests/dtor-early-exit.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -28,9 +28,9 @@ // don't want these called void ?{}(A * a) { assert( false ); } -void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = malloc(); } +void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); } void ?{}(A * a, char * name, int * ptr) { assert( false ); } A ?=?(A * a, A a) { sout | "assign " | a->name | " " | a.name; return a; } -void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = malloc(); } +void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = (int*)malloc(); } void ^?{}(A * a) { sout | "destruct " | a->name | endl; free(a->x); } Index: src/tests/test.py =================================================================== --- src/tests/test.py (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/tests/test.py (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -168,30 +168,34 @@ def run_test_instance(t, generate, dry_run, debug) : - # print formated name - name_txt = "%20s " % t.name - - #run the test instance and collect the result - test_failed, error = run_single_test(t, generate, dry_run, debug) - - # update output based on current action - if generate : - failed_txt = "ERROR" - success_txt = "Done" - else : - failed_txt = "FAILED" - success_txt = "PASSED" - - #print result with error if needed - text = name_txt + (failed_txt if test_failed else success_txt) - out = sys.stdout - if error : - text = text + "\n" + error - out = sys.stderr - - print(text, file = out); - sys.stdout.flush() - sys.stderr.flush() - - return test_failed + try : + # print formated name + name_txt = "%20s " % t.name + + #run the test instance and collect the result + test_failed, error = run_single_test(t, generate, dry_run, debug) + + # update output based on current action + if generate : + failed_txt = "ERROR" + success_txt = "Done" + else : + failed_txt = "FAILED" + success_txt = "PASSED" + + #print result with error if needed + text = name_txt + (failed_txt if test_failed else success_txt) + out = sys.stdout + if error : + text = text + "\n" + error + out = sys.stderr + + print(text, file = out); + sys.stdout.flush() + sys.stderr.flush() + return test_failed + + except KeyboardInterrupt: + test_failed = True + # run the given list of tests with the given parameters @@ -209,5 +213,5 @@ pool = Pool(jobs) try : - results = pool.map_async(partial(run_test_instance, generate=generate, dry_run=dry_run, debug=debug), tests ).get(99999999) + results = pool.map_async(partial(run_test_instance, generate=generate, dry_run=dry_run, debug=debug), tests ).get(9999) except KeyboardInterrupt: pool.terminate() Index: src/tests/thread.c =================================================================== --- src/tests/thread.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) +++ src/tests/thread.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -0,0 +1,43 @@ +#include +#include +#include +#include + +struct First { thread t; simple_lock* lock; }; +struct Second { thread t; simple_lock* lock; }; + +DECL_THREAD(First); +DECL_THREAD(Second); + +void ?{}( First * this, simple_lock* lock ) { this->lock = lock; } +void ?{}( Second * this, simple_lock* lock ) { this->lock = lock; } + +void main(First* this) { + for(int i = 0; i < 10; i++) { + sout | "First : Suspend No." | i + 1 | endl; + yield(); + } + unlock(this->lock); +} + +void main(Second* this) { + lock(this->lock); + for(int i = 0; i < 10; i++) { + sout | "Second : Suspend No." | i + 1 | endl; + yield(); + } +} + + +int main(int argc, char* argv[]) { + simple_lock lock; + sout | "User main begin" | endl; + { + // processor p; + { + scoped(First) f = { &lock }; + scoped(Second) s = { &lock }; + } + } + sout | "User main end" | endl; +} Index: src/tests/tupleVariadic.c =================================================================== --- src/tests/tupleVariadic.c (revision c0aa3360803b4a312708b494a8067a91f03e9e8f) +++ src/tests/tupleVariadic.c (revision b4d65c7215f3dc3f625972b509f35bfa55439694) @@ -29,5 +29,5 @@ } -forall(otype T, ttype Params | { void ?{}(T *, Params); }) +forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new(Params p);