swift-mirror/lib/IRGen/GenStruct.cpp

//===--- GenStruct.cpp - Swift IR Generation For 'struct' Types -----------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
//  This file implements IR generation for struct types.
//
//===----------------------------------------------------------------------===//

#include "GenStruct.h"

#include "swift/AST/Types.h"
#include "swift/AST/Decl.h"
#include "swift/AST/Expr.h"
#include "swift/AST/Pattern.h"
#include "swift/Basic/Optional.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"

#include "GenInit.h"
#include "GenSequential.h"
#include "GenType.h"
#include "IRGenFunction.h"
#include "IRGenModule.h"
#include "Linking.h"
#include "LValue.h"
#include "Explosion.h"

using namespace swift;
using namespace irgen;

namespace {
  class StructFieldInfo : public SequentialField<StructFieldInfo> {
  public:
    StructFieldInfo(VarDecl *field, const TypeInfo &type)
      : SequentialField(type), Field(field) {}

    /// The field.
    VarDecl *Field;

    StringRef getFieldName() const {
      return Field->getName().str();
    }
  };

  /// Layout information for struct types.
  class StructTypeInfo :
    public SequentialTypeInfo<StructTypeInfo, StructFieldInfo> {
  public:
    StructTypeInfo(llvm::Type *T, unsigned numFields)
      : SequentialTypeInfo(T, numFields) {
    }
  };

  class StructTypeBuilder :
    public SequentialTypeBuilder<StructTypeBuilder, StructTypeInfo, VarDecl*> {

    llvm::StructType *StructTy;
  public:
    StructTypeBuilder(IRGenModule &IGM, llvm::StructType *structTy) :
      SequentialTypeBuilder(IGM), StructTy(structTy) {
    }

    StructTypeInfo *construct(void *buffer, ArrayRef<VarDecl*> fields) {
      return ::new(buffer) StructTypeInfo(StructTy, fields.size());
    }

    StructFieldInfo getFieldInfo(VarDecl *field, const TypeInfo &fieldTI) {
      return StructFieldInfo(field, fieldTI);
    }

    Type getType(VarDecl *field) { return field->getType(); }

    void performLayout(ArrayRef<const TypeInfo *> fieldTypes) {
      StructLayout layout(IGM, LayoutKind::NonHeapObject,
                          LayoutStrategy::Optimal, fieldTypes, StructTy);
      recordLayout(layout, StructTy);
    }
  };
}  // end anonymous namespace.

namespace {
  class PhysicalStructMember : public PhysicalPathComponent {
    const StructFieldInfo &Field;

  public:
    PhysicalStructMember(const StructFieldInfo &field) : Field(field) {}

    OwnedAddress offset(IRGenFunction &IGF, OwnedAddress addr) const {
      Address project = Field.projectAddress(IGF, addr);
      return OwnedAddress(project, addr.getOwner());
    }
  };
}

static void emitValueConstructor(IRGenModule &IGM,
                                 llvm::Function *fn,
                                 ConstructorDecl *ctor) {
  IRGenFunction IGF(IGM, ctor->getType(), ctor->getArguments(),
                    ExplosionKind::Minimal, 0, fn, Prologue::Standard);

  auto thisDecl = ctor->getImplicitThisDecl();
  const StructTypeInfo &thisTI =
      IGF.getFragileTypeInfo(thisDecl->getType()).as<StructTypeInfo>();
  Initialization I;
  I.registerObject(IGF, I.getObjectForDecl(thisDecl),
                   thisDecl->hasFixedLifetime() ? NotOnHeap : OnHeap, thisTI);
  OwnedAddress addr = I.emitVariable(IGF, thisDecl, thisTI);

  unsigned FieldIndex = 0;
  TuplePattern *TP = cast<TuplePattern>(ctor->getArguments());
  StructDecl *SD = cast<StructDecl>(ctor->getDeclContext());
  for (Decl *D : SD->getMembers()) {
    if (isa<VarDecl>(D) && !cast<VarDecl>(D)->isProperty()) {
      TypedPattern *P = cast<TypedPattern>(TP->getFields()[FieldIndex].getPattern());
      NamedPattern *NP = cast<NamedPattern>(P->getSubPattern());
      OwnedAddress inaddr = IGF.getLocalVar(NP->getDecl());

      Explosion e(ExplosionKind::Minimal);
      const StructFieldInfo &field = thisTI.getFields()[FieldIndex];
      field.getTypeInfo().load(IGF, inaddr, e);
      field.getTypeInfo().initialize(IGF, e, field.projectAddress(IGF, addr));
      FieldIndex++;
    }
  }

  I.markInitialized(IGF, I.getObjectForDecl(thisDecl));

  IGF.emitConstructorBody(ctor);
}

LValue swift::irgen::emitPhysicalStructMemberLValue(IRGenFunction &IGF,
                                                    MemberRefExpr *E) {
  LValue lvalue = IGF.emitLValue(E->getBase());
  LValueType *lvalTy = E->getBase()->getType()->castTo<LValueType>();
  StructType *T = lvalTy->getObjectType()->castTo<StructType>();
  const StructTypeInfo &info = IGF.getFragileTypeInfo(T).as<StructTypeInfo>();

  // FIXME: This field index computation is an ugly hack.
  unsigned FieldIndex = 0;
  for (Decl *D : T->getDecl()->getMembers()) {
    if (D == E->getDecl())
      break;
    if (isa<VarDecl>(D) && !cast<VarDecl>(D)->isProperty())
      ++FieldIndex;
  }

  const StructFieldInfo &field = info.getFields()[FieldIndex];
  lvalue.add<PhysicalStructMember>(field);
  return lvalue;
}


/// emitStructType - Emit all the declarations associated with this oneof type.
void IRGenModule::emitStructDecl(StructDecl *st) {
  // FIXME: This is mostly copy-paste from emitExtension;
  // figure out how to refactor! 
  for (Decl *member : st->getMembers()) {
    switch (member->getKind()) {
    case DeclKind::Import:
    case DeclKind::TopLevelCode:
    case DeclKind::Protocol:
    case DeclKind::Extension:
    case DeclKind::Destructor:
    case DeclKind::OneOfElement:
      llvm_unreachable("decl not allowed in struct!");

    // We can have meaningful initializers for variables, but
    // we can't handle them yet.  For the moment, just ignore them.
    case DeclKind::PatternBinding:
      continue;

    case DeclKind::Subscript:
      // Getter/setter will be handled separately.
      continue;
    case DeclKind::TypeAlias:
      continue;
    case DeclKind::OneOf:
      emitOneOfDecl(cast<OneOfDecl>(member));
      continue;
    case DeclKind::Struct:
      emitStructDecl(cast<StructDecl>(member));
      continue;
    case DeclKind::Class:
      emitClassDecl(cast<ClassDecl>(member));
      continue;
    case DeclKind::Var:
      if (cast<VarDecl>(member)->isProperty())
        // Getter/setter will be handled separately.
        continue;
      // FIXME: Will need an implementation here for resilience
      continue;
    case DeclKind::Func: {
      FuncDecl *func = cast<FuncDecl>(member);
      if (func->isStatic()) {
        // Eventually this won't always be the right thing.
        emitStaticMethod(func);
      } else {
        emitInstanceMethod(func);
      }
      continue;
    }
    case DeclKind::Constructor: {
      auto ctor = cast<ConstructorDecl>(member);
      if (!ctor->getBody()) {
        llvm::Function *fn = getAddrOfConstructor(ctor, ExplosionKind::Minimal);
        emitValueConstructor(*this, fn, ctor);
      } else {
        emitConstructor(ctor);
      }
      continue;
    }
    }
    llvm_unreachable("bad extension member kind");
  }
}

const TypeInfo *TypeConverter::convertStructType(StructDecl *D) {
  StructTypeBuilder builder(IGM, IGM.createNominalType(D));

  // Collect all the fields from the type.
  SmallVector<VarDecl*, 8> fields;
  for (Decl *D : D->getMembers())
    if (VarDecl *VD = dyn_cast<VarDecl>(D))
      if (!VD->isProperty())
        fields.push_back(VD);

  // Allocate the TypeInfo and register it as a forward-declaration.
  // We do this before we look at any of the child types.
  auto structTI = builder.create(fields);
  auto typesMapKey = D->getDeclaredType().getPointer();
  Types.insert(std::make_pair(typesMapKey, structTI));

  // Complete the type and return it.
  return builder.complete(fields);
}