Index: src/AST/Bitfield.hpp =================================================================== --- src/AST/Bitfield.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Bitfield.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,70 @@ +// +// 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. +// +// Bitfield.hpp -- +// +// Author : Aaron B. Moss +// Created On : Thu May 9 10:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu May 9 10:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include // for ffs + +/// Make a type a bitfield. +/// Include in type definition to add operators. Used to simulate inheritance because union +/// does not allow it. Requires type to have `unsigned val` field +/// @param BFType Name of containing type +#define MakeBitfield( BFType ) \ + constexpr BFType() : val( 0 ) {} \ + constexpr BFType( unsigned int v ) : val( v ) {} \ + bool operator[]( unsigned int i ) const { return val & (1 << i); } \ + bool any() const { return val != 0; } \ + void reset() { val = 0; } \ + int ffs() { return ::ffs( val ) - 1; } \ + BFType operator&=( BFType other ) { \ + val &= other.val; return *this; \ + } \ + BFType operator&( BFType other ) const { \ + BFType q = other; \ + q &= *this; \ + return q; \ + } \ + BFType operator|=( BFType other ) { \ + val |= other.val; return *this; \ + } \ + BFType operator|( BFType other ) const { \ + BFType q = other; \ + q |= *this; \ + return q; \ + } \ + BFType operator-=( BFType other ) { \ + val &= ~other.val; return *this; \ + } + +/// Adds default printing operator to a bitfield type. +/// Include in definition to add print function, requires other bitfield operators. +/// @param N Number of bits in bitfield +#define MakeBitfieldPrint( N ) \ + static const char* Names[]; \ + void print( std::ostream & os ) const { \ + if ( (*this).any() ) { \ + for ( unsigned int i = 0; i < N; i += 1 ) { \ + if ( (*this)[i] ) { \ + os << Names[i] << ' '; \ + } \ + } \ + } \ + } + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Decl.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,47 @@ +// +// 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. +// +// Decl.cpp -- +// +// Author : Aaron B. Moss +// Created On : Thu May 9 10:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu May 9 10:00:00 2019 +// Update Count : 1 +// + +#include + +#include "Decl.hpp" + +#include "Fwd.hpp" // for UniqueId +#include "Node.hpp" // for readonly + +namespace ast { +// To canonicalize declarations +static UniqueId lastUniqueId = 0; + +using IdMapType = std::unordered_map< UniqueId, readonly >; +static IdMapType idMap; + +void Decl::fixUniqueId() { + if ( uniqueId ) return; // ensure only set once + uniqueId = ++lastUniqueId; + idMap[ uniqueId ] = this; +} + +readonly Decl::fromId( UniqueId id ) { + IdMapType::const_iterator i = idMap.find( id ); + if ( i != idMap.end() ) return i->second; + return {}; +} +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Decl.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,84 @@ +// +// 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. +// +// Decl.hpp -- +// +// Author : Aaron B. Moss +// Created On : Thu May 9 10:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu May 9 10:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include +#include + +#include "Fwd.hpp" // for UniqueId +#include "LinkageSpec.hpp" +#include "Node.hpp" // for ptr, readonly +#include "ParseNode.hpp" +#include "StorageClasses.hpp" +#include "Visitor.hpp" + +namespace ast { +class Attribute; +class Expr; + +/// Base declaration class +class Decl : public ParseNode { +public: + std::string name; + Storage::Classes storage; + Linkage::Spec linkage; + UniqueId uniqueId = 0; + bool extension = false; + + Decl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, + Linkage::Spec linkage ) + : ParseNode( loc ), name( name ), storage( storage ), linkage( linkage ) {} + + Decl* set_extension( bool ex ) { extension = ex; return this; } + + /// Ensures this node has a unique ID + void fixUniqueId(); + /// Get canonical declaration for unique ID + static readonly fromId( UniqueId id ); + + virtual Decl* accept( Visitor& v ) override = 0; +private: + virtual Decl* clone() const override = 0; +}; + +/// Typed declaration base class +class DeclWithType : public Decl { +public: + /// Represents the type with all types and typedefs expanded. + /// This field is generated by SymTab::Validate::Pass2 + std::string mangleName; + /// Stores the scope level at which the variable was declared. + /// Used to access shadowed identifiers. + int scopeLevel = 0; + + std::vector> attributes; + Function::Specs funcSpecs; + ptr asmName; + bool isDeleted = false; + + DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage, + Linkage::Spec linkage, std::vector>&& attrs, Function::Specs fs ) + : Decl( loc, name, storage, linkage ), mangleName(), attributes( std::move(attrs) ), + funcSpecs(fs), asmName() {} +}; + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/DeclReplacer.cpp =================================================================== --- src/AST/DeclReplacer.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/DeclReplacer.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,22 @@ +// +// 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. +// +// DeclReplacer.cpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 13:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 13:00:00 2019 +// Update Count : 1 +// + +#error unimplemented + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/DeclReplacer.hpp =================================================================== --- src/AST/DeclReplacer.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/DeclReplacer.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,40 @@ +// +// 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. +// +// DeclReplacer.hpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 13:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 13:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include + +#include "Node.hpp" + +namespace ast { + class DeclWithType; + class TypeDecl; + + namespace DeclReplacer { + using DeclMap = std::unordered_map< DeclWithType*, DeclWithType* >; + using TypeMap = std::unordered_map< TypeDecl*, TypeDecl* >; + + void replace( Node* node, const DeclMap& declMap ); + void replace( Node* node, const TypeMap& typeMap ); + void replace( Node* node, const DeclMap& declMap, const TypeMap& typeMap ); + } +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Label.hpp =================================================================== --- src/AST/Label.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Label.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,56 @@ +// +// 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. +// +// Label.hpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 13:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 13:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include +#include +#include + +#include "Node.hpp" +#include "Common/CodeLocation.h" + +namespace ast { + + class Attribute; + + /// Named labels for statements + class Label { + public: + CodeLocation location; + std::string name; + std::vector< ptr > attributes; + + Label( CodeLocation loc, const std::string& name = "", + const std::vector>& attrs = std::vector>{} ) + : location( loc ), name( name ), attributes( attrs ) {} + + operator std::string () const { return name; } + bool empty() { return name.empty(); } + }; + + inline bool operator== ( const Label& l1, const Label& l2 ) { return l1.name == l2.name; } + inline bool operator!= ( const Label& l1, const Label& l2 ) { return !(l1 == l2); } + inline bool operator< ( const Label& l1, const Label& l2 ) { return l1.name < l2.name; } + + inline std::ostream& operator<< ( std::ostream& out, const Label& l ) { return out << l.name; } + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/LinkageSpec.cpp =================================================================== --- src/AST/LinkageSpec.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/LinkageSpec.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,62 @@ +// +// 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. +// +// LinkageSpec.hpp -- +// +// Author : Aaron B. Moss +// Created On : Thu May 9 10:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu May 9 10:00:00 2019 +// Update Count : 1 +// + +#include "LinkageSpec.hpp" + +#include +#include // for unique_ptr +#include + +#include "Common/CodeLocation.h" +#include "Common/SemanticError.h" + +namespace ast { + namespace Linkage { + Spec update( CodeLocation loc, Spec spec, const std::string * cmd ) { + assert( cmd ); + std::unique_ptr guard( cmd ); // allocated by lexer + if ( *cmd == "\"Cforall\"" ) { + spec.is_mangled = true; + return spec; + } else if ( *cmd == "\"C\"" ) { + spec.is_mangled = false; + return spec; + } else { + SemanticError( loc, "Invalid linkage specifier " + *cmd ); + } + } + + + std::string name( Spec spec ) { + switch ( spec ) { + case Intrinsic: return "intrinsic"; + case C: return "C"; + case Cforall: return "Cforall"; + case AutoGen: return "autogenerated cfa"; + case Compiler: return "compiler built-in"; + case BuiltinCFA: return "cfa built-in"; + case BuiltinC: return "c built-in"; + default: return ""; + } + } + + } +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/LinkageSpec.hpp =================================================================== --- src/AST/LinkageSpec.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/LinkageSpec.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,80 @@ +// +// 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. +// +// LinkageSpec.hpp -- +// +// Author : Aaron B. Moss +// Created On : Thu May 9 10:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu May 9 10:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include + +#include "Bitfield.hpp" +#include "Common/CodeLocation.h" + +namespace ast { + + namespace Linkage { + + /// Bitflags for linkage specifiers + enum { + Mangle = 1 << 0, + Generate = 1 << 1, + Overrideable = 1 << 2, + Builtin = 1 << 3, + GccBuiltin = 1 << 4 + }; + + /// Bitflag type for storage classes + union Spec { + unsigned int val; + struct { + bool is_mangled : 1; + bool is_generatable : 1; + bool is_overrideable : 1; + bool is_builtin : 1; + bool is_gcc_builtin : 1; + }; + + MakeBitfield( Spec ) + }; + + /// If `cmd` = "C" returns `spec` with `is_mangled = false`. + /// If `cmd` = "Cforall" returns `spec` with `is_mangled = true`. + Spec update( CodeLocation loc, Spec spec, const std::string * cmd ); + + /// A human-readable name for this spec + std::string name( Spec spec ); + + // Pre-defined flag combinations + + /// C built-in defined in prelude + constexpr Spec Intrinsic = { Mangle | Generate | Overrideable | Builtin }; + /// Ordinary Cforall + constexpr Spec Cforall = { Mangle | Generate }; + /// C code: not overloadable, not mangled + constexpr Spec C = { Generate }; + /// Built by translator (e.g. struct assignment) + constexpr Spec AutoGen = { Mangle | Generate | Overrideable }; + /// GCC internal + constexpr Spec Compiler = { Mangle | Builtin | GccBuiltin }; + /// Mangled builtins + constexpr Spec BuiltinCFA = { Mangle | Generate | Builtin }; + /// Non-mangled builtins + constexpr Spec BuiltinC = { Generate | Builtin }; + } +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Node.hpp =================================================================== --- src/AST/Node.hpp (revision f47f8876561ac211c0d7f0c72e79060c8ab30298) +++ src/AST/Node.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -1,11 +1,42 @@ +// +// 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. +// +// Node.hpp -- +// +// Author : Thierry Delisle +// Created On : Wed May 8 10:27:04 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 11:00:00 2019 +// Update Count : 2 +// + #pragma once -#include +#include +#include namespace ast { + +class Visitor; + +/// Base class for all AST nodes. +/// Keeps both strong and weak reference counts. class Node { public: + // override defaults to ensure assignment doesn't + // change/share reference counts + Node() = default; + Node(const Node&) : strong_ref(0), weak_ref(0) {} + Node(Node&&) : strong_ref(0), weak_ref(0) {} + Node& operator= (const Node&) = delete; + Node& operator= (Node&&) = delete; virtual ~Node() = default; + virtual Node* accept( Visitor& v ) = 0; + + /// Types of node references enum class ref_type { strong, @@ -35,4 +66,7 @@ private: + /// Make a copy of this node; should be overridden in subclass with more precise return type + virtual Node* clone() const = 0; + mutable size_t strong_ref = 0; mutable size_t weak_ref = 0; @@ -58,4 +92,6 @@ } +std::ostream& operator<< ( std::ostream& out, const Node* node ); + // Base class for the smart pointer types // should never really be used. @@ -76,5 +112,4 @@ ptr_base( ptr_base && o ) : node(o.node) { if( node ) node->increment(ref_t); - if( node ) node->decrement(o_ref_t); } @@ -89,5 +124,4 @@ if(o.node == node) return *this; assign(o.node); - if( node ) node->decrement(o_ref_t); return *this; } @@ -112,8 +146,16 @@ }; +/// Owning pointer to node template< typename node_t > using ptr = ptr_base< node_t, Node::ref_type::strong >; +/// Observing pointer to node template< typename node_t > using readonly = ptr_base< node_t, Node::ref_type::weak >; } + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/ParseNode.hpp =================================================================== --- src/AST/ParseNode.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/ParseNode.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,44 @@ +// +// 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. +// +// ParseNode.hpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 11:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 11:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include "Node.hpp" + +#include "Common/CodeLocation.h" + +namespace ast { + + /// AST node with an included source location + class ParseNode : public Node { + public: + CodeLocation location; + + // Default constructor is deliberately omitted, all ParseNodes must have a location. + // Escape hatch if needed is to explicitly pass a default-constructed location, but + // this should be used sparingly. + + ParseNode( const CodeLocation& loc ) : Node(), location(loc) {} + + ParseNode( const ParseNode& o ) = default; + }; + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Stmt.cpp =================================================================== --- src/AST/Stmt.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Stmt.cpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,32 @@ +// +// 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. +// +// Stmt.cpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 13:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 13:00:00 2019 +// Update Count : 1 +// + +#include "Stmt.hpp" + +#include "DeclReplacer.hpp" + +// --- CompoundStmt + +namespace ast { + CompoundStmt::CompoundStmt( const CompoundStmt& o ) : Stmt(o), kids(o.kids) { + assert(!"implemented"); + } +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Stmt.hpp =================================================================== --- src/AST/Stmt.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) +++ src/AST/Stmt.hpp (revision 2bb4a01b67c9bef5d552f56c14abeca79a2985d2) @@ -0,0 +1,97 @@ +// +// 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. +// +// Stmt.hpp -- +// +// Author : Aaron B. Moss +// Created On : Wed May 8 13:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 8 13:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include +#include // for move +#include + +#include "Label.hpp" +#include "Node.hpp" // for node, ptr +#include "ParseNode.hpp" +#include "Visitor.hpp" +#include "Common/CodeLocation.h" + +namespace ast { + +class Expr; + +/// Base statement node +class Stmt : public ParseNode { +public: + std::vector