squiid/llvm
1
0
Fork 0
Code Issues Pull requests Activity

[flang] clean up for push

Browse source 
Original-commit: flang-compiler/f18@8b5bbcedba
Reviewed-on: https://github.com/flang-compiler/f18/pull/111
Tree-same-pre-rewrite: false
This commit is contained in:
peter klausler 2018-06-22 13:40:56 -07:00
parent 4c11bc07d4
commit efcbf1f7df
8 changed files with 39 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
flang/lib/common/idioms.h
View file

@ -85,7 +85,7 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
// Invoke CLASS_TRAIT(traitName) to define a trait, then put
// using traitName = std::true_type; (or false_type)
// into the appropriate class definitions. You can then use
// typename std::enable_if<traitName<...>, ...>::type
// typename std::enable_if_t<traitName<...>, ...>
// in template specialization definitions.
#define CLASS_TRAIT(T) \
namespace class_trait_ns_##T { \
@ -94,14 +94,12 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
template<typename A> \
constexpr bool has_trait{decltype(test<A>(nullptr))::value}; \
template<typename A> \
constexpr typename std::enable_if<has_trait<A>, bool>::type \
trait_value() { \
constexpr typename std::enable_if_t<has_trait<A>, bool> trait_value() { \
using U = typename A::T; \
return U::value; \
} \
template<typename A> \
constexpr typename std::enable_if<!has_trait<A>, bool>::type \
trait_value() { \
constexpr typename std::enable_if_t<!has_trait<A>, bool> trait_value() { \
return false; \
} \
} \

1
flang/lib/evaluate/CMakeLists.txt
View file

@ -18,7 +18,6 @@ add_library(FortranEvaluate
integer.cc
logical.cc
real.cc
type.cc
)
target_link_libraries(FortranEvaluate

16
flang/lib/evaluate/common.h
View file

@ -16,13 +16,14 @@
#define FORTRAN_EVALUATE_COMMON_H_
#include "../common/enum-set.h"
#include "../common/idioms.h"
#include <cinttypes>
namespace Fortran::evaluate {
// Integers are always ordered; reals may not be.
enum class Ordering { Less, Equal, Greater };
enum class Relation { Less, Equal, Greater, Unordered };
ENUM_CLASS(Ordering, Less, Equal, Greater)
ENUM_CLASS(Relation, Less, Equal, Greater, Unordered)
static constexpr Ordering CompareUnsigned(std::uint64_t x, std::uint64_t y) {
if (x < y) {
@ -64,13 +65,8 @@ static constexpr Relation Reverse(Relation relation) {
}
}
enum class RealFlag {
Overflow,
DivideByZero,
InvalidArgument,
Underflow,
Inexact
};
ENUM_CLASS(
RealFlag, Overflow, DivideByZero, InvalidArgument, Underflow, Inexact)
using RealFlags = common::EnumSet<RealFlag, 5>;
@ -83,7 +79,7 @@ template<typename A> struct ValueWithRealFlags {
RealFlags flags;
};
enum class Rounding { TiesToEven, ToZero, Down, Up, TiesAwayFromZero };
ENUM_CLASS(Rounding, TiesToEven, ToZero, Down, Up, TiesAwayFromZero)
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
constexpr bool IsHostLittleEndian{false};

12
flang/lib/evaluate/expression.h
View file

@ -16,10 +16,13 @@
#define FORTRAN_EVALUATE_EXPRESSION_H_
// Represent Fortran expressions in a type-safe manner.
// Expressions are the sole owners of their constituents; there is no
// Expressions are the sole owners of their constituents; i.e., there is no
// context-independent hash table or sharing of common subexpressions.
// Both deep copy and move semantics are supported for expression construction.
// Both deep copy and move semantics are supported for expression construction
// and manipulation in place.
// TODO: variable and function references
// TODO: elevate some intrinsics to operations
// TODO: convenience wrappers for constructing conversions
#include "common.h"
#include "type.h"
@ -41,7 +44,7 @@ struct AnyCharacterExpr;
struct AnyIntegerOrRealExpr;
// Helper base classes to manage subexpressions, which are known as data members
// named 'x' and (for binary operations) 'y'.
// named 'x' and, for binary operations, 'y'.
template<typename A> struct Unary {
Unary(const A &a) : x{std::make_unique<A>(a)} {}
Unary(std::unique_ptr<const A> &&a) : x{std::move(a)} {}
@ -488,6 +491,9 @@ struct AnyIntegerOrRealExpr {
};
// Convenience functions and operator overloadings for expression construction.
// These definitions are created with temporary helper macros to reduce
// C++ boilerplate. All combinations of lvalue and rvalue references are
// allowed for operands.
#define UNARY(FUNC, CONSTR) \
template<typename A> A FUNC(const A &x) { return {typename A::CONSTR{x}}; }
UNARY(Parentheses, Parentheses)

31
flang/lib/evaluate/type.cc
View file

@ -1,31 +0,0 @@
// Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "type.h"
#include <string>
namespace Fortran::evaluate {
std::string CategoryName(Category c) {
switch (c) {
case Category::Integer: return "Integer";
case Category::Real: return "Real";
case Category::Complex: return "Complex";
case Category::Logical: return "Logical";
case Category::Character: return "Character";
case Category::Derived: return "Derived";
}
return ""; // placate g++
}
} // namespace Fortran::evaluate

7
flang/lib/evaluate/type.h
View file

@ -24,21 +24,20 @@
#include "integer.h"
#include "logical.h"
#include "real.h"
#include "../common/idioms.h"
#include <string>
#include <variant>
namespace Fortran::evaluate {
enum class Category { Integer, Real, Complex, Logical, Character, Derived };
std::string CategoryName(Category);
ENUM_CLASS(Category, Integer, Real, Complex, Logical, Character, Derived)
template<Category C, int KIND> struct TypeBase {
static constexpr Category category{C};
static constexpr int kind{KIND};
static constexpr bool hasLen{false};
static std::string Dump() {
return CategoryName(category) + '(' + std::to_string(kind) + ')';
return EnumToString(category) + '(' + std::to_string(kind) + ')';
}
};

14
flang/lib/parser/basic-parsers.h
View file

@ -969,18 +969,16 @@ private:
// With a single argument that is a parser with a usable value of
// type A, construct<T>(p) invokes T's explicit constructor T(A &&).
template<class T, typename PA>
constexpr
typename std::enable_if<std::is_same_v<Success, typename PA::resultType>,
Construct01<T, PA>>::type
construct(const PA &parser) {
constexpr std::enable_if_t<std::is_same_v<Success, typename PA::resultType>,
Construct01<T, PA>>
construct(const PA &parser) {
return Construct01<T, PA>{parser};
}
template<typename T, typename PA>
constexpr
typename std::enable_if<!std::is_same_v<Success, typename PA::resultType>,
Construct1<T, PA>>::type
construct(const PA &parser) {
constexpr std::enable_if_t<!std::is_same_v<Success, typename PA::resultType>,
Construct1<T, PA>>
construct(const PA &parser) {
return Construct1<T, PA>{parser};
}

26
flang/lib/parser/parse-tree-visitor.h
View file

@ -35,17 +35,15 @@ namespace Fortran::parser {
// Default case for visitation of non-class data members and strings
template<typename A, typename V>
typename std::enable_if<!std::is_class_v<A> ||
std::is_same_v<std::string, A>>::type
Walk(const A &x, V &visitor) {
std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A>> Walk(
const A &x, V &visitor) {
if (visitor.Pre(x)) {
visitor.Post(x);
}
}
template<typename A, typename M>
typename std::enable_if<!std::is_class_v<A> ||
std::is_same_v<std::string, A>>::type
Walk(A &x, M &mutator) {
std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A>> Walk(
A &x, M &mutator) {
if (mutator.Pre(x)) {
mutator.Post(x);
}
@ -142,27 +140,27 @@ void Walk(std::pair<A, B> &x, M &mutator) {
// Trait-determined traversal of empty, tuple, union, and wrapper classes.
template<typename A, typename V>
typename std::enable_if<EmptyTrait<A>>::type Walk(const A &x, V &visitor) {
std::enable_if_t<EmptyTrait<A>> Walk(const A &x, V &visitor) {
if (visitor.Pre(x)) {
visitor.Post(x);
}
}
template<typename A, typename M>
typename std::enable_if<EmptyTrait<A>>::type Walk(A &x, M &mutator) {
std::enable_if_t<EmptyTrait<A>> Walk(A &x, M &mutator) {
if (mutator.Pre(x)) {
mutator.Post(x);
}
}
template<typename A, typename V>
typename std::enable_if<TupleTrait<A>>::type Walk(const A &x, V &visitor) {
std::enable_if_t<TupleTrait<A>> Walk(const A &x, V &visitor) {
if (visitor.Pre(x)) {
Walk(x.t, visitor);
visitor.Post(x);
}
}
template<typename A, typename M>
typename std::enable_if<TupleTrait<A>>::type Walk(A &x, M &mutator) {
std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
if (mutator.Pre(x)) {
Walk(x.t, mutator);
mutator.Post(x);
@ -170,14 +168,14 @@ typename std::enable_if<TupleTrait<A>>::type Walk(A &x, M &mutator) {
}
template<typename A, typename V>
typename std::enable_if<UnionTrait<A>>::type Walk(const A &x, V &visitor) {
std::enable_if_t<UnionTrait<A>> Walk(const A &x, V &visitor) {
if (visitor.Pre(x)) {
Walk(x.u, visitor);
visitor.Post(x);
}
}
template<typename A, typename M>
typename std::enable_if<UnionTrait<A>>::type Walk(A &x, M &mutator) {
std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
if (mutator.Pre(x)) {
Walk(x.u, mutator);
mutator.Post(x);
@ -185,14 +183,14 @@ typename std::enable_if<UnionTrait<A>>::type Walk(A &x, M &mutator) {
}
template<typename A, typename V>
typename std::enable_if<WrapperTrait<A>>::type Walk(const A &x, V &visitor) {
std::enable_if_t<WrapperTrait<A>> Walk(const A &x, V &visitor) {
if (visitor.Pre(x)) {
Walk(x.v, visitor);
visitor.Post(x);
}
}
template<typename A, typename M>
typename std::enable_if<WrapperTrait<A>>::type Walk(A &x, M &mutator) {
std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
if (mutator.Pre(x)) {
Walk(x.v, mutator);
mutator.Post(x);