[cfe-commits] r138112 - /cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp
Eric Christopher
echristo at apple.com
Fri Aug 19 15:16:26 PDT 2011
Author: echristo
Date: Fri Aug 19 17:16:25 2011
New Revision: 138112
URL: http://llvm.org/viewvc/llvm-project?rev=138112&view=rev
Log:
Migrate 2008-10-29-WrongOffset.cpp from llvm/test/FrontendC++.
Added:
cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp
Added: cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp?rev=138112&view=auto
==============================================================================
--- cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp (added)
+++ cfe/trunk/test/CodeGenCXX/2008-10-29-WrongOffset.cpp Fri Aug 19 17:16:25 2011
@@ -0,0 +1,489 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+// PR2917
+
+#include <complex>
+template < int Dim, class T, class EngineTag > class Engine;
+template < class Subject, class Sub1, bool SV > struct View1Implementation;
+template < class LayoutTag, class PatchTag > struct MultiPatch;
+template < class LayoutTag, class PatchTag, int Dim2 > struct MultiPatchView;
+template < class Engine, class SubDomain > struct NewEngine
+{
+};
+template < class T > class DomainTraits;
+template < class DomT, class T, int Dim > struct DomainTraitsDomain
+{
+ typedef DomT NewDomain1_t;
+};
+template < int Dim > class Interval;
+template < int Dim > class Loc;
+template < class DT > class DomainBase
+{
+};
+
+template < int Dim, class DT > class Domain:public DomainBase < DT >
+{
+};
+template < int Dim > struct DomainTraits <Interval < Dim >
+ >:public DomainTraitsDomain < Interval < Dim >, int, Dim >
+{
+ enum
+ {
+ singleValued = false
+ };
+};
+template < class T1 > struct NewDomain1
+{
+ typedef typename DomainTraits < T1 >::NewDomain1_t SliceType_t;
+};
+template < class Domain, class Sub > struct TemporaryNewDomain1
+{
+ typedef typename NewDomain1 < Sub >::SliceType_t SliceType_t;
+};
+template < int Dim > class Interval:public Domain < Dim,
+ DomainTraits < Interval < Dim > > >
+{
+};
+template < int Dim > class GuardLayers
+{
+};
+template < class T > class Observer
+{
+};
+
+template < class T > class Observable
+{
+private:T & observed_m;
+ int count_m;
+};
+
+class RefCounted
+{
+};
+template < class T > class RefCountedPtr
+{
+public:typedef RefCountedPtr < T > This_t;
+ RefCountedPtr (T * const pT):ptr_m (pT)
+ {
+ }
+ inline T *operator-> () const
+ {
+ }
+ T *ptr_m;
+};
+
+template < class Dom, class T > class DomainMap
+{
+};
+
+template < class LayoutTag, int Dim > struct MultiPatchLayoutTraits
+{
+};
+template < int Dim > class LayoutBaseData
+{
+public:typedef Interval < Dim > Domain_t;
+ Domain_t domain_m;
+};
+template < int Dim, class LBD > class LayoutBase
+{
+public:typedef LayoutBaseData < Dim > LayoutData_t;
+ typedef typename LayoutData_t::Domain_t Domain_t;
+ typedef GuardLayers < Dim > GuardLayers_t;
+ inline const Domain_t & domain () const
+ {
+ return pdata_m->domain_m;
+ }
+ inline const Domain_t & innerDomain () const
+ {
+ }
+ inline GuardLayers_t externalGuards () const
+ {
+ }
+ RefCountedPtr < LBD > pdata_m;
+};
+template < class Tag > struct Remote;
+struct Brick
+{
+};
+template < class Thing, class Sub > struct View1
+{
+};
+template < int Dim, class T, class LayoutTag,
+ class PatchTag > struct NewEngine <Engine < Dim, T, MultiPatch < LayoutTag,
+ PatchTag > >, Interval < Dim > >
+{
+ typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
+ Dim > >Type_t;
+};
+template < int Dim, class T, class LayoutTag, class PatchTag,
+ int Dim2 > struct NewEngine <Engine < Dim, T, MultiPatchView < LayoutTag,
+ PatchTag, Dim2 > >, Interval < Dim > >
+{
+ typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
+ Dim2 > >Type_t;
+};
+template < int Dim, class T, class LayoutTag,
+ class PatchTag > class Engine < Dim, T, MultiPatch < LayoutTag,
+ PatchTag > >:public Observer < typename MultiPatchLayoutTraits < LayoutTag,
+ Dim >::Layout_t >
+{
+public:typedef MultiPatch < LayoutTag, PatchTag > Tag_t;
+ typedef Interval < Dim > Domain_t;
+};
+template < int Dim, class T, class LayoutTag, class PatchTag,
+ int Dim2 > class Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
+ Dim2 > >
+{
+public:typedef MultiPatchView < LayoutTag, PatchTag, Dim2 > Tag_t;
+ typedef Interval < Dim > Domain_t;
+ typedef T Element_t;
+ enum
+ {
+ dimensions = Dim
+ };
+};
+class Full;
+template < int Dim, class T = double, class EngineTag = Full > class Vector {
+};
+
+template < int Dim > inline Interval < Dim >
+shrinkRight (const Interval < Dim > &dom, int s)
+{
+}
+
+template < int Dim > class GridLayout;
+struct GridTag
+{
+};
+template < int Dim > struct MultiPatchLayoutTraits <GridTag, Dim >
+{
+ typedef GridLayout < Dim > Layout_t;
+};
+template < int Dim > class GridLayoutData:public LayoutBaseData < Dim >,
+ public RefCounted, public Observable < GridLayoutData < Dim > >
+{
+ typedef int AxisIndex_t;
+ mutable DomainMap < Interval < 1 >, AxisIndex_t > mapAloc_m[Dim];
+};
+template < int Dim > class GridLayout:public LayoutBase < Dim,
+ GridLayoutData < Dim > >, public Observable < GridLayout < Dim > >,
+ public Observer < GridLayoutData < Dim > >
+{
+public:typedef GridLayout < Dim > This_t;
+ GridLayout ();
+};
+template < class MeshTag, class T, class EngineTag > class Field;
+enum CenteringType
+{
+ VertexType, EdgeType, FaceType, CellType
+};
+enum ContinuityType
+{
+ Continuous = 0, Discontinuous
+};
+template < int Dim > class Centering
+{
+public:typedef Loc < Dim > Orientation;
+ inline int size () const
+ {
+ }
+};
+template < int Dim > const Centering < Dim >
+canonicalCentering (const enum CenteringType type,
+ const enum ContinuityType discontinuous,
+ const int dimension = 0);
+template < class Mesh, class T, class EngineTag > class FieldEngine
+{
+public:enum
+ {
+ dimensions = Mesh::dimensions
+ };
+ enum
+ {
+ Dim = dimensions
+ };
+ typedef Engine < Dim, T, EngineTag > Engine_t;
+ typedef typename Engine_t::Domain_t Domain_t;
+ typedef GuardLayers < Dim > GuardLayers_t;
+template < class Layout2 > FieldEngine (const Centering < Dim > ¢ering, const Layout2 & layout, const Mesh & mesh, int materials = 1):num_materials_m (materials), centering_m (centering),
+ stride_m (centering.size ()), physicalCellDomain_m (layout.domain ()),
+ guards_m (layout.externalGuards ()), mesh_m (mesh)
+ {
+ }
+ unsigned int num_materials_m;
+ Centering < Dim > centering_m;
+ int stride_m;
+ Domain_t physicalCellDomain_m;
+ GuardLayers_t guards_m;
+ Mesh mesh_m;
+};
+
+template < class Subject > class SubFieldView;
+template < class Mesh, class T,
+ class EngineTag > class SubFieldView < Field < Mesh, T, EngineTag > >
+{
+public:typedef Field < Mesh, T, EngineTag > Type_t;
+};
+
+template < int Dim, class Mesh, class Domain > struct NewMeshTag
+{
+ typedef Mesh Type_t;
+};
+template < class Mesh, class T, class EngineTag,
+ class Domain > struct View1Implementation <Field < Mesh, T, EngineTag >,
+ Domain, false >
+{
+ typedef Field < Mesh, T, EngineTag > Subject_t;
+ typedef typename Subject_t::Engine_t Engine_t;
+ typedef typename NewEngine < Engine_t, Domain >::Type_t NewEngine_t;
+ typedef typename NewEngine_t::Element_t NewT_t;
+ typedef typename NewEngine_t::Tag_t NewEngineTag_t;
+ typedef typename NewMeshTag < NewEngine_t::dimensions, Mesh,
+ Domain >::Type_t NewMeshTag_t;
+ typedef Field < NewMeshTag_t, NewT_t, NewEngineTag_t > Type_t;
+};
+template < class Mesh, class T, class EngineTag,
+ class Sub1 > struct View1 <Field < Mesh, T, EngineTag >, Sub1 >
+{
+ typedef Field < Mesh, T, EngineTag > Subject_t;
+ typedef typename Subject_t::Domain_t Domain_t;
+ typedef TemporaryNewDomain1 < Domain_t, Sub1 > NewDomain_t;
+ typedef typename NewDomain_t::SliceType_t SDomain_t;
+ enum
+ {
+ sv = DomainTraits < SDomain_t >::singleValued
+ };
+ typedef View1Implementation < Subject_t, SDomain_t, sv > Dispatch_t;
+ typedef typename Dispatch_t::Type_t Type_t;
+};
+template < class Mesh, class T = double, class EngineTag = Brick > class Field {
+public:typedef Mesh MeshTag_t;
+ typedef Mesh Mesh_t;
+ typedef Field < Mesh, T, EngineTag > This_t;
+ typedef FieldEngine < Mesh, T, EngineTag > FieldEngine_t;
+ enum
+ {
+ dimensions = FieldEngine_t::dimensions
+ };
+ typedef Engine < dimensions, T, EngineTag > Engine_t;
+ typedef typename Engine_t::Domain_t Domain_t;
+ typedef Centering < dimensions > Centering_t;
+ template < class Layout2 > Field (const Centering_t & centering,
+ const Layout2 & layout,
+ const Mesh_t &
+ mesh):fieldEngine_m (centering, layout,
+ mesh)
+ {
+ }
+ inline typename SubFieldView < This_t >::Type_t center (int c) const
+ {
+ }
+ inline typename View1 < This_t, Domain_t >::Type_t all () const
+ {
+ }
+ template < class T1 > const This_t & operator= (const T1 & rhs) const
+ {
+ }
+private: FieldEngine_t fieldEngine_m;
+};
+
+struct UniformRectilinearTag
+{
+};
+struct CartesianTag
+{
+};
+template < class MeshTraits > struct CartesianURM;
+template < class MeshTraits > class UniformRectilinearMeshData;
+template < class MeshTraits > class UniformRectilinearMesh;
+template < int Dim, typename T = double, class MeshTag =
+ UniformRectilinearTag, class CoordinateSystemTag = CartesianTag, int CDim =
+ Dim > struct MeshTraits;
+template < int Dim, typename T, class MeshTag, class CoordinateSystemTag,
+ int CDim > struct MeshTraitsBase
+{
+ typedef MeshTraits < Dim, T, MeshTag, CoordinateSystemTag,
+ CDim > MeshTraits_t;
+ enum
+ {
+ dimensions = Dim
+ };
+ typedef Vector < CDim, T > PointType_t;
+};
+template < int Dim, typename T, int CDim > struct MeshTraits <Dim, T,
+ UniformRectilinearTag, CartesianTag, CDim >:public MeshTraitsBase < Dim, T,
+ UniformRectilinearTag, CartesianTag, CDim >
+{
+ typedef typename MeshTraitsBase < Dim, T, UniformRectilinearTag,
+ CartesianTag, CDim >::MeshTraits_t MeshTraits_t;
+ typedef CartesianURM < MeshTraits_t > CoordinateSystem_t;
+ typedef UniformRectilinearMeshData < MeshTraits_t > MeshData_t;
+ typedef UniformRectilinearMesh < MeshTraits_t > Mesh_t;
+ typedef Vector < CDim, T > SpacingsType_t;
+};
+template < int Dim > class NoMeshData:public RefCounted
+{
+public:NoMeshData ()
+ {
+ }
+ template < class Layout >
+ explicit NoMeshData (const Layout &
+ layout):physicalVertexDomain_m (layout.
+ innerDomain ()),
+ physicalCellDomain_m (shrinkRight (physicalVertexDomain_m, 1)),
+ totalVertexDomain_m (layout.domain ()),
+ totalCellDomain_m (shrinkRight (totalVertexDomain_m, 1))
+ {
+ }
+private:Interval < Dim > physicalVertexDomain_m, physicalCellDomain_m;
+ Interval < Dim > totalVertexDomain_m, totalCellDomain_m;
+};
+
+template < class MeshTraits > class UniformRectilinearMeshData:public NoMeshData <
+ MeshTraits::
+ dimensions >
+{
+public:typedef typename
+ MeshTraits::MeshData_t
+ MeshData_t;
+ typedef typename
+ MeshTraits::PointType_t
+ PointType_t;
+ typedef typename
+ MeshTraits::SpacingsType_t
+ SpacingsType_t;
+ enum
+ {
+ dimensions = MeshTraits::dimensions
+ };
+ template < class Layout > UniformRectilinearMeshData (const Layout & layout,
+ const PointType_t &
+ origin,
+ const SpacingsType_t &
+ spacings):
+ NoMeshData <
+ dimensions > (layout),
+ origin_m (origin),
+ spacings_m (spacings)
+ {
+ }
+private:PointType_t origin_m;
+ SpacingsType_t
+ spacings_m;
+};
+
+template < class MeshTraits > class UniformRectilinearMesh:public MeshTraits::
+ CoordinateSystem_t
+{
+public:typedef MeshTraits
+ MeshTraits_t;
+ typedef typename
+ MeshTraits::MeshData_t
+ MeshData_t;
+ typedef typename
+ MeshTraits::PointType_t
+ PointType_t;
+ typedef typename
+ MeshTraits::SpacingsType_t
+ SpacingsType_t;
+ enum
+ {
+ dimensions = MeshTraits::dimensions
+ };
+ template < class Layout >
+ inline UniformRectilinearMesh (const Layout & layout,
+ const PointType_t & origin,
+ const SpacingsType_t & spacings):
+ data_m (new MeshData_t (layout, origin, spacings))
+ {
+ }
+private:RefCountedPtr < MeshData_t > data_m;
+};
+
+template < class MeshTraits > struct GenericURM
+{
+};
+template < class MeshTraits > struct CartesianURM:
+ public
+ GenericURM <
+ MeshTraits >
+{
+};
+template < int
+ dim,
+ class
+ MeshTag = UniformRectilinearTag, class CoordinateSystemTag = CartesianTag > struct ParallelTraits {
+ enum
+ {
+ Dim = dim
+ };
+ typedef
+ GridLayout <
+ dim >
+ Layout_t;
+ typedef
+ MeshTraits <
+ dim, double,
+ MeshTag,
+ CoordinateSystemTag >
+ MeshTraits_t;
+ typedef typename
+ MeshTraits_t::Mesh_t
+ Mesh_t;
+ typedef
+ MultiPatch <
+ GridTag,
+ Remote <
+ Brick > >
+ Engine_t;
+};
+template < class ComputeTraits > struct RhalkTraits:
+ public
+ ComputeTraits
+{
+ typedef typename
+ ComputeTraits::Mesh_t
+ Mesh_t;
+ typedef typename
+ ComputeTraits::Engine_t
+ Engine_t;
+ enum
+ {
+ Dim = ComputeTraits::Dim
+ };
+ typedef
+ Centering <
+ Dim >
+ Centering_t;
+ typedef typename
+ Mesh_t::SpacingsType_t
+ Spacings_t;
+ typedef
+ Field <
+ Mesh_t, double,
+ Engine_t >
+ Scalar_t;
+};
+enum
+{
+ Dim = 3
+};
+typedef
+ RhalkTraits <
+ ParallelTraits <
+ Dim,
+ UniformRectilinearTag,
+CartesianTag > >
+ Traits_t;
+Vector < Dim > origin;
+Traits_t::Spacings_t spacings;
+int
+main (int argc, char **argv)
+{
+ Traits_t::Layout_t layout;
+ Traits_t::Mesh_t mesh (layout, origin, spacings);
+ Traits_t::Centering_t face =
+ canonicalCentering < Traits_t::Dim > (FaceType, Continuous);
+ Traits_t::Scalar_t v (face, layout, mesh);
+ for (int i = 0; i < Dim; ++i)
+ v.center (i).all () = std::numeric_limits < double >::signaling_NaN ();
+}
More information about the cfe-commits
mailing list