//===------- TypeConversion.cpp - Converting GCC types to LLVM types ------===//
//
// Copyright (C) 2005 to 2013  Chris Lattner, Duncan Sands et al.
//
// This file is part of DragonEgg.
//
// DragonEgg 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 2, or (at your option) any later version.
//
// DragonEgg 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
// DragonEgg; see the file COPYING.  If not, write to the Free Software
// Foundation, 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
//
//===----------------------------------------------------------------------===//
// This is the code that converts GCC tree types into LLVM types.
//===----------------------------------------------------------------------===//

// Plugin headers
#include "dragonegg/ABI.h"
#include "dragonegg/ADT/IntervalList.h"
#include "dragonegg/ADT/Range.h"
#include "dragonegg/Cache.h"
#include "dragonegg/TypeConversion.h"

// LLVM headers
#include "llvm/ADT/SCCIterator.h"
#include "llvm/ADT/StringExtras.h"

// System headers
#include <gmp.h>
#include <map>

// GCC headers
#include "auto-host.h"
#ifndef ENABLE_BUILD_WITH_CXX
#include <cstring> // Otherwise included by system.h with C linkage.
extern "C" {
#endif
#include "config.h"
// Stop GCC declaring 'getopt' as it can clash with the system's declaration.
#undef HAVE_DECL_GETOPT
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"

#include "flags.h"
#ifndef ENABLE_BUILD_WITH_CXX
} // extern "C"
#endif

// Trees header.
#include "dragonegg/Trees.h"

using namespace llvm;

static LLVMContext &Context = getGlobalContext();

/// SCCInProgress - Set of mutually dependent types currently being converted.
static const std::vector<tree_node *> *SCCInProgress;

//===----------------------------------------------------------------------===//
//                       ... ContainedTypeIterator ...
//===----------------------------------------------------------------------===//

/// ContainedTypeIterator - A convenience class for viewing a type as a graph,
/// where the nodes of the graph are types and there is an edge from type A to
/// type B iff A "contains" B.  A record type contains the types of its fields,
/// an array type contains the element type, a pointer type contains the type
/// pointed to and so on.  Use the begin, end and increment methods to iterate
/// over all of the types contained in a given type.
namespace {

class ContainedTypeIterator {
  /// type_ref - Either a TREE_LIST node, in which case TREE_VALUE gives the
  /// contained type, or some other kind of tree node and TREE_TYPE gives the
  /// contained type.  A null value indicates the end iterator.
  tree type_ref;

  /// ContainedTypeIterator - Convenience constructor for internal use.
  explicit ContainedTypeIterator(const tree &t) : type_ref(t) {}

public:
  /// Dereference operator.
  tree operator*() {
    return isa<TREE_LIST>(type_ref) ? TREE_VALUE(type_ref)
                                    : TREE_TYPE(type_ref);
  }
  ;

  /// Comparison operators.
  bool operator==(const ContainedTypeIterator &other) const {
    return other.type_ref == this->type_ref;
  }
  bool operator!=(const ContainedTypeIterator &other) const {
    return !(*this == other);
  }

  /// Prefix increment operator.
  ContainedTypeIterator &operator++() {
    assert(type_ref && "Incrementing end iterator!");

    switch (TREE_CODE(type_ref)) {
    default:
      debug_tree(type_ref);
      llvm_unreachable("Unexpected tree kind!");
    case ARRAY_TYPE:
    case COMPLEX_TYPE:
    case POINTER_TYPE:
    case REFERENCE_TYPE:
    case VECTOR_TYPE:
      // Here type_ref is the type being iterated over.  These types all have
      // only one contained type, so incrementing returns the end iterator.
      type_ref = 0;
      break;

    case FIELD_DECL:
      // Here type_ref is a field of the record or union type being iterated
      // over.  Move on to the next field.
      do
        type_ref = TREE_CHAIN(type_ref);
      while (type_ref && !isa<FIELD_DECL>(type_ref));
      break;

    case FUNCTION_TYPE:
    case METHOD_TYPE:
      // Here type_ref is the type being iterated over and the iterator refers
      // to the function return type.  Move on to the first function argument
      // (a TREE_LIST node).
      type_ref = TYPE_ARG_TYPES(type_ref);
      break;

    case TREE_LIST:
      // Here type_ref belongs to the argument list of the function or method
      // being iterated over.  Move on to the next function argument.
      type_ref = TREE_CHAIN(type_ref);
      // If the function takes a fixed number of arguments then the argument
      // list is terminated by void_list_node.  This is not a real argument.
      if (type_ref == void_list_node)
        type_ref = 0;
      break;
    }

    return *this;
  }

  /// begin - Return an iterator referring to the first type contained in the
  /// given type.
  static ContainedTypeIterator begin(tree type) {
    switch (TREE_CODE(type)) {
    default:
      llvm_unreachable("Unknown type!");

    case BOOLEAN_TYPE:
    case ENUMERAL_TYPE:
    case FIXED_POINT_TYPE:
    case INTEGER_TYPE:
#if (GCC_MINOR > 5)
    case NULLPTR_TYPE:
#endif
    case OFFSET_TYPE:
    case REAL_TYPE:
    case VOID_TYPE:
      // No contained types.
      return end();

    case ARRAY_TYPE:
    case COMPLEX_TYPE:
    case POINTER_TYPE:
    case REFERENCE_TYPE:
    case VECTOR_TYPE:
      // Use the type itself as the "pointer" to the contained type.
      return ContainedTypeIterator(type);

    case QUAL_UNION_TYPE:
    case RECORD_TYPE:
    case UNION_TYPE:
      // The contained types are the types of the record's fields.  Use the
      // first FIELD_DECL as the "pointer" to the first contained type.
      for (tree field = TYPE_FIELDS(type); field; field = TREE_CHAIN(field))
        if (isa<FIELD_DECL>(field))
          return ContainedTypeIterator(field);
      return end();

    case FUNCTION_TYPE:
    case METHOD_TYPE:
      // The contained types are the return type and the argument types (in
      // the case of METHOD_TYPE nothing special needs to be done for 'this'
      // since it occurs explicitly in the argument list).  Return the type
      // itself as the "pointer" to the return type; incrementing will move
      // the iterator on to the argument types.
      // Note that static chains for nested functions cannot be obtained from
      // the function type which is why there is no attempt to handle them.
      return ContainedTypeIterator(type);
    }
  }

  /// end - Return the end iterator for contained type iteration.
  static ContainedTypeIterator end() { return ContainedTypeIterator(0); }
};

} // Unnamed namespace.

//===----------------------------------------------------------------------===//
//                                 Utilities
//===----------------------------------------------------------------------===//

/// ArrayLengthOf - Returns the length of the given gcc array type, or NO_LENGTH
/// if the array has variable or unknown length.
uint64_t ArrayLengthOf(tree type) {
  assert(isa<ARRAY_TYPE>(type) && "Only for array types!");
  // Workaround for missing sanity checks in older versions of GCC.
  if ((GCC_MINOR == 5 && GCC_MICRO < 3) || (GCC_MINOR == 6 && GCC_MICRO < 2))
    if (!TYPE_DOMAIN(type) || !TYPE_MAX_VALUE(TYPE_DOMAIN(type)))
      return NO_LENGTH;
  tree range = array_type_nelts(type); // The number of elements minus one.
  // Bail out if the array has variable or unknown length.
  if (!isInt64(range, false))
    return NO_LENGTH;
  int64_t Range = (int64_t) getInt64(range, false);
  return Range < 0 ? 0 : 1 + (uint64_t) Range;
}

/// set_decl_index - Associate a non-negative number with the given GCC
/// field declaration.
static int set_decl_index(tree t, int i) {
  assert(i >= 0 && "Negative indices not allowed!");
  setCachedInteger(t, i);
  return i;
}

/// get_decl_index - Get the non-negative number associated with the given GCC
/// field decl.  Returns a negative value if no such association has been made.
static int get_decl_index(tree t) {
  int Idx;
  if (getCachedInteger(t, Idx))
    return Idx;
  return -1;
}

/// GetFieldIndex - Return the index of the field in the given LLVM type that
/// corresponds to the GCC field declaration 'decl'.  This means that the LLVM
/// and GCC fields start in the same byte (if 'decl' is a bitfield, this means
/// that its first bit is within the byte the LLVM field starts at).  Returns
/// INT_MAX if there is no such LLVM field.
int GetFieldIndex(tree decl, Type *Ty) {
  assert(isa<FIELD_DECL>(decl) && "Expected a FIELD_DECL!");
  // FIXME: The following test sometimes fails when compiling Fortran90 because
  // DECL_CONTEXT does not point to the containing type, but some other type!
  //  assert(Ty == ConvertType(DECL_CONTEXT(decl)) && "Field not for this type!");

  // If we previously cached the field index, return the cached value.
  unsigned Index = (unsigned) get_decl_index(decl);
  if (Index <= INT_MAX)
    return Index;

  // TODO: At this point we could process all fields of DECL_CONTEXT(decl), and
  // incrementally advance over the StructLayout.  This would make indexing be
  // O(N) rather than O(N log N) if all N fields are used.  It's not clear if it
  // would really be a win though.

  StructType *STy = dyn_cast<StructType>(Ty);
  // If this is not a struct type, then for sure there is no corresponding LLVM
  // field (we do not require GCC record types to be converted to LLVM structs).
  if (!STy)
    return set_decl_index(decl, INT_MAX);

  // If this is an empty struct then there is no corresponding LLVM field.
  if (STy->element_begin() == STy->element_end())
    return set_decl_index(decl, INT_MAX);

  // If the field declaration is at a variable or humongous offset then there
  // can be no corresponding LLVM field.
  if (!OffsetIsLLVMCompatible(decl))
    return set_decl_index(decl, INT_MAX);

  // Find the LLVM field that contains the first bit of the GCC field.
  uint64_t OffsetInBytes = getFieldOffsetInBits(decl) / 8; // Ignore bit in byte
  const StructLayout *SL = getDataLayout().getStructLayout(STy);
  Index = SL->getElementContainingOffset(OffsetInBytes);

  // The GCC field must start in the first byte of the LLVM field.
  if (OffsetInBytes != SL->getElementOffset(Index))
    return set_decl_index(decl, INT_MAX);

  // We are not able to cache values bigger than INT_MAX, so bail out if the
  // LLVM field index is that huge.
  if (Index >= INT_MAX)
    return set_decl_index(decl, INT_MAX);

  // Found an appropriate LLVM field - return it.
  return set_decl_index(decl, Index);
}

/// getPointerToType - Returns the LLVM register type to use for a pointer to
/// the given GCC type.
Type *getPointerToType(tree type) {
  if (isa<VOID_TYPE>(type))
    // void* -> byte*
    return GetUnitPointerType(Context);
  // FIXME: Handle address spaces.
  return ConvertType(type)->getPointerTo();
}

/// GetUnitType - Returns an integer one address unit wide if 'NumUnits' is 1;
/// otherwise returns an array of such integers with 'NumUnits' elements.  For
/// example, on a machine which has 16 bit bytes returns an i16 or an array of
/// i16.
Type *GetUnitType(LLVMContext &C, unsigned NumUnits) {
  Type *UnitTy = IntegerType::get(C, BITS_PER_UNIT);
  if (NumUnits == 1)
    return UnitTy;
  return ArrayType::get(UnitTy, NumUnits);
}

/// GetUnitPointerType - Returns an LLVM pointer type which points to memory one
/// address unit wide.  For example, on a machine which has 16 bit bytes returns
/// an i16*.
Type *GetUnitPointerType(LLVMContext &C, unsigned AddrSpace) {
  return GetUnitType(C)->getPointerTo(AddrSpace);
}

/// isSized - Return true if the GCC type has a size, perhaps variable.  Note
/// that this returns false for function types, for which the GCC type size
/// doesn't represent anything useful for us.
static bool isSized(tree type) {
  if (isa<FUNCTION_TYPE>(type) || isa<METHOD_TYPE>(type))
    return false;
  return TYPE_SIZE(type);
}

/// isSizeCompatible - Return true if the specified gcc type is guaranteed to be
/// turned by ConvertType into an LLVM type of the same size (i.e. TYPE_SIZE the
/// same as getTypeAllocSizeInBits).
bool isSizeCompatible(tree type) {
  if (!isSized(type))
    return false;
  return isInt64(TYPE_SIZE(type), true);
}

//===----------------------------------------------------------------------===//
//                   Matching LLVM types with GCC trees
//===----------------------------------------------------------------------===//

static Type *CheckTypeConversion(tree type, Type *Ty) {
#ifndef NDEBUG
  bool Mismatch = false;
  // If the GCC type has a size, check that the LLVM type does too.  Note that
  // the LLVM type may have a size when the GCC type does not.  For example a
  // C variable length array int[] may be converted into [0 x i32].
  if (isSized(type) && !Ty->isSized()) {
    Mismatch = true;
    errs() << "The GCC type has a size but the LLVM type does not!\n";
  }
  // Check that the LLVM and GCC types really do have the same size when we say
  // they do.
  if (isSizeCompatible(type) && Ty->isSized()) {
    uint64_t GCCSize = getInt64(TYPE_SIZE(type), true);
    uint64_t LLVMSize = getDataLayout().getTypeAllocSizeInBits(Ty);
    if (LLVMSize != GCCSize) {
      Mismatch = true;
      errs() << "GCC size: " << GCCSize << "; LLVM size: " << LLVMSize << "!\n";
    }
  }
  // Check that the LLVM type has the same alignment or less than the GCC type.
  if (Ty->isSized()) {
    unsigned GCCAlign = TYPE_ALIGN(type);
    unsigned LLVMAlign = getDataLayout().getABITypeAlignment(Ty) * 8;
    if (LLVMAlign > GCCAlign) {
      Mismatch = true;
      errs() << "GCC align: " << GCCAlign << "; LLVM align: " << LLVMAlign
             << "\n";
    }
  }
  if (Mismatch) {
    errs() << "GCC: ";
    debug_tree(type);
    errs() << "LLVM: ";
    Ty->print(errs());
    llvm_unreachable("\nLLVM type doesn't represent GCC type!");
  }
#endif

  (void) type;
  return Ty;
}

// RememberTypeConversion - Associate an LLVM type with a GCC type.
// These are lazily computed by ConvertType.
static Type *RememberTypeConversion(tree type, Type *Ty) {
  CheckTypeConversion(type, Ty);
  setCachedType(type, Ty);
  return Ty;
}

//===----------------------------------------------------------------------===//
//                       Type Conversion Utilities
//===----------------------------------------------------------------------===//

// isPassedByInvisibleReference - Return true if an argument of the specified
// type should be passed in by invisible reference.
//
bool isPassedByInvisibleReference(tree Type) {
  // Don't crash in this case.
  if (Type == error_mark_node)
    return false;

  // FIXME: Search for TREE_ADDRESSABLE in calls.c, and see if there are other
  // cases that make arguments automatically passed in by reference.
  return TREE_ADDRESSABLE(Type) || TYPE_SIZE(Type) == 0 ||
         !isa<INTEGER_CST>(TYPE_SIZE(Type));
}

//===----------------------------------------------------------------------===//
//                             ... getRegType ...
//===----------------------------------------------------------------------===//

/// getRegType - Returns the LLVM type to use for registers that hold a value
/// of the scalar GCC type 'type'.  All of the EmitReg* routines use this to
/// determine the LLVM type to return.
Type *getRegType(tree type) {
  // Check that the type mode doesn't depend on the type variant (various bits
  // of the plugin rely on this).
  assert(TYPE_MODE(type) == TYPE_MODE(TYPE_MAIN_VARIANT(type)) &&
         "Type mode differs between variants!");

  // LLVM doesn't care about variants such as const, volatile, or restrict.
  type = TYPE_MAIN_VARIANT(type);

  // NOTE: Any changes made here need to be reflected in LoadRegisterFromMemory,
  // StoreRegisterToMemory and ExtractRegisterFromConstant.
  assert(!isa<AGGREGATE_TYPE>(type) && "Registers must have a scalar type!");
  assert(!isa<VOID_TYPE>(type) && "Registers cannot have void type!");

  switch (TREE_CODE(type)) {

  default:
    debug_tree(type);
    llvm_unreachable("Unknown register type!");

  case BOOLEAN_TYPE:
  case ENUMERAL_TYPE:
  case INTEGER_TYPE:
    // For integral types, convert based on the type precision.  For example,
    // this turns bool into i1 while ConvertType probably turns it into i8 or
    // i32.
    return IntegerType::get(Context, TYPE_PRECISION(type));

  case COMPLEX_TYPE: {
    Type *EltTy = getRegType(TREE_TYPE(type));
    return StructType::get(EltTy, EltTy, NULL);
  }

#if (GCC_MINOR > 5)
  case NULLPTR_TYPE:
    return GetUnitPointerType(Context, TYPE_ADDR_SPACE(type));
#endif

  case OFFSET_TYPE:
    return getDataLayout().getIntPtrType(Context, TYPE_ADDR_SPACE(type));

  case POINTER_TYPE:
  case REFERENCE_TYPE: {
    // void* -> byte*
    unsigned AS = TYPE_ADDR_SPACE(type);
    return isa<VOID_TYPE>(TREE_TYPE(type))
           ? GetUnitPointerType(Context, AS)
           : ConvertType(TREE_TYPE(type))->getPointerTo(AS);
  }

  case REAL_TYPE:
    if (TYPE_PRECISION(type) == 32)
      return Type::getFloatTy(Context);
    if (TYPE_PRECISION(type) == 64)
      return Type::getDoubleTy(Context);
    if (TYPE_PRECISION(type) == 80)
      return Type::getX86_FP80Ty(Context);
    if (TYPE_PRECISION(type) == 128)
#ifdef TARGET_POWERPC
      return Type::getPPC_FP128Ty(Context);
#else
    // IEEE quad precision.
    return Type::getFP128Ty(Context);
#endif
    debug_tree(type);
    llvm_unreachable("Unknown FP type!");

  case VECTOR_TYPE:
    return VectorType::get(getRegType(TREE_TYPE(type)),
                           TYPE_VECTOR_SUBPARTS(type));

  }
}

//===----------------------------------------------------------------------===//
//                            ... ConvertType ...
//===----------------------------------------------------------------------===//

static Type *ConvertArrayTypeRecursive(tree type) {
  Type *ElementTy = ConvertType(TREE_TYPE(type));
  uint64_t NumElements = ArrayLengthOf(type);

  if (NumElements == NO_LENGTH) // Variable length array?
    NumElements = 0;

  // Create the array type.
  Type *Ty = ArrayType::get(ElementTy, NumElements);

  // If the array is underaligned, wrap it in a packed struct.
  if (TYPE_ALIGN(type) < TYPE_ALIGN(main_type(type)))
    Ty = StructType::get(Context, Ty, /*isPacked*/ true);

  // If the user increased the alignment of the array element type, then the
  // size of the array is rounded up by that alignment even though the size
  // of the array element type is not (!).  Correct for this if necessary by
  // adding padding.  May also need padding if the element type has variable
  // size and the array type has variable length, but by a miracle the product
  // gives a constant size.
  if (isInt64(TYPE_SIZE(type), true)) {
    uint64_t PadBits = getInt64(TYPE_SIZE(type), true) -
                       getDataLayout().getTypeAllocSizeInBits(Ty);
    if (PadBits) {
      Type *Padding = ArrayType::get(Type::getInt8Ty(Context), PadBits / 8);
      Ty = StructType::get(Ty, Padding, NULL);
    }
  }

  return Ty;
}

namespace {
class FunctionTypeConversion : public DefaultABIClient {
  Type *&RetTy;
  SmallVectorImpl<Type *> &ArgTypes;
  CallingConv::ID &CallingConv;
  unsigned Offset;
  bool isShadowRet;
  bool KNRPromotion;
public:
  FunctionTypeConversion(Type *&retty, SmallVectorImpl<Type *> &AT,
                         CallingConv::ID &CC, bool KNR)
      : RetTy(retty), ArgTypes(AT), CallingConv(CC), Offset(0),
        KNRPromotion(KNR) {
    CallingConv = CallingConv::C;
    isShadowRet = false;
  }

  /// getCallingConv - This provides the desired CallingConv for the function.
  CallingConv::ID getCallingConv(void) { return CallingConv; }

  bool isShadowReturn() const { return isShadowRet; }

  /// HandleScalarResult - This callback is invoked if the function returns a
  /// simple scalar result value.
  void HandleScalarResult(Type *RTy) { this->RetTy = RTy; }

  /// HandleAggregateResultAsScalar - This callback is invoked if the function
  /// returns an aggregate value by bit converting it to the specified scalar
  /// type and returning that.
  void HandleAggregateResultAsScalar(Type *ScalarTy, unsigned Off = 0) {
    RetTy = ScalarTy;
    this->Offset = Off;
  }

  /// HandleAggregateResultAsAggregate - This callback is invoked if the function
  /// returns an aggregate value using multiple return values.
  void HandleAggregateResultAsAggregate(Type *AggrTy) { RetTy = AggrTy; }

  /// HandleShadowResult - Handle an aggregate or scalar shadow argument.
  void HandleShadowResult(PointerType *PtrArgTy, bool RetPtr) {
    // This function either returns void or the shadow argument,
    // depending on the target.
    RetTy = RetPtr ? PtrArgTy : Type::getVoidTy(Context);

    // In any case, there is a dummy shadow argument though!
    ArgTypes.push_back(PtrArgTy);

    // Also, note the use of a shadow argument.
    isShadowRet = true;
  }

  /// HandleAggregateShadowResult - This callback is invoked if the function
  /// returns an aggregate value by using a "shadow" first parameter, which is
  /// a pointer to the aggregate, of type PtrArgTy.  If RetPtr is set to true,
  /// the pointer argument itself is returned from the function.
  void HandleAggregateShadowResult(PointerType *PtrArgTy, bool RetPtr) {
    HandleShadowResult(PtrArgTy, RetPtr);
  }

  /// HandleScalarShadowResult - This callback is invoked if the function
  /// returns a scalar value by using a "shadow" first parameter, which is a
  /// pointer to the scalar, of type PtrArgTy.  If RetPtr is set to true,
  /// the pointer argument itself is returned from the function.
  void HandleScalarShadowResult(PointerType *PtrArgTy, bool RetPtr) {
    HandleShadowResult(PtrArgTy, RetPtr);
  }

  void HandlePad(llvm::Type *LLVMTy) { HandleScalarArgument(LLVMTy, 0, 0); }

  void HandleScalarArgument(llvm::Type *LLVMTy, tree type,
                            unsigned /*RealSize*/ = 0) {
    if (KNRPromotion) {
      if (type == float_type_node)
        LLVMTy = ConvertType(double_type_node);
      else if (LLVMTy->isIntegerTy(16) || LLVMTy->isIntegerTy(8) ||
               LLVMTy->isIntegerTy(1))
        LLVMTy = Type::getInt32Ty(Context);
    }
    ArgTypes.push_back(LLVMTy);
  }

  /// HandleByInvisibleReferenceArgument - This callback is invoked if a pointer
  /// (of type PtrTy) to the argument is passed rather than the argument itself.
  void HandleByInvisibleReferenceArgument(llvm::Type *PtrTy, tree /*type*/) {
    ArgTypes.push_back(PtrTy);
  }

  /// HandleByValArgument - This callback is invoked if the aggregate function
  /// argument is passed by value. It is lowered to a parameter passed by
  /// reference with an additional parameter attribute "ByVal".
  void HandleByValArgument(llvm::Type *LLVMTy, tree type) {
    HandleScalarArgument(LLVMTy->getPointerTo(), type);
  }

  /// HandleFCAArgument - This callback is invoked if the aggregate function
  /// argument is a first class aggregate passed by value.
  void HandleFCAArgument(llvm::Type *LLVMTy, tree /*type*/) {
    ArgTypes.push_back(LLVMTy);
  }
};
}

static void HandleArgumentExtension(tree ArgTy, AttrBuilder &AttrBuilder) {
  if (isa<BOOLEAN_TYPE>(ArgTy)) {
    if (TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)) < INT_TYPE_SIZE)
      AttrBuilder.addAttribute(Attribute::ZExt);
  } else if (isa<INTEGER_TYPE>(ArgTy) &&
             TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)) < INT_TYPE_SIZE) {
    if (TYPE_UNSIGNED(ArgTy))
      AttrBuilder.addAttribute(Attribute::ZExt);
    else
      AttrBuilder.addAttribute(Attribute::SExt);
  }
}

/// ConvertParamListToLLVMSignature - This method is used to build the argument
/// type list for K&R prototyped functions.  In this case, we have to figure out
/// the type list (to build a FunctionType) from the actual DECL_ARGUMENTS list
/// for the function.  This method takes the DECL_ARGUMENTS list (Args), and
/// fills in Result with the argument types for the function.  It returns the
/// specified result type for the function.
FunctionType *ConvertArgListToFnType(
    tree type, ArrayRef<tree> Args, tree static_chain, bool KNRPromotion,
    CallingConv::ID &CallingConv, AttributeSet &PAL) {
  tree ReturnType = TREE_TYPE(type);
  SmallVector<Type *, 8> ArgTys;
  Type *RetTy(Type::getVoidTy(Context));

  FunctionTypeConversion Client(RetTy, ArgTys, CallingConv, KNRPromotion);
  DefaultABI ABIConverter(Client);

#ifdef TARGET_ADJUST_LLVM_CC
  TARGET_ADJUST_LLVM_CC(CallingConv, type);
#endif

  // Builtins are always prototyped, so this isn't one.
  ABIConverter.HandleReturnType(ReturnType, current_function_decl, false);

  SmallVector<AttributeSet, 8> Attrs;
  LLVMContext &Context = RetTy->getContext();

  // Compute whether the result needs to be zext or sext'd.
  AttrBuilder RAttrBuilder;
  HandleArgumentExtension(ReturnType, RAttrBuilder);

// Allow the target to change the attributes.
#ifdef TARGET_ADJUST_LLVM_RETATTR
  TARGET_ADJUST_LLVM_RETATTR(type, RAttrBuilder);
#endif

  if (RAttrBuilder.hasAttributes())
    Attrs.push_back(
        AttributeSet::get(Context, AttributeSet::ReturnIndex, RAttrBuilder));

  // If this function returns via a shadow argument, the dest loc is passed
  // in as a pointer.  Mark that pointer as struct-ret and noalias.
  if (ABIConverter.isShadowReturn()) {
    AttrBuilder B;
    B.addAttribute(Attribute::StructRet).addAttribute(Attribute::NoAlias);
    Attrs.push_back(AttributeSet::get(Context, ArgTys.size(), B));
  }

  std::vector<Type *> ScalarArgs;
  if (static_chain) {
    // Pass the static chain as the first parameter.
    ABIConverter.HandleArgument(TREE_TYPE(static_chain), ScalarArgs);
    // Mark it as the chain argument.
    Attrs.push_back(AttributeSet::get(Context, ArgTys.size(), Attribute::Nest));
  }

  for (ArrayRef<tree>::iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
    tree ArgTy = TREE_TYPE(*I);

    // Determine if there are any attributes for this param.
    AttrBuilder PAttrBuilder;

    ABIConverter.HandleArgument(ArgTy, ScalarArgs, &PAttrBuilder);

    // Compute zext/sext attributes.
    HandleArgumentExtension(ArgTy, PAttrBuilder);

    // Compute noalias attributes.
    if (isa<ACCESS_TYPE>(ArgTy) && TYPE_RESTRICT(ArgTy))
      PAttrBuilder.addAttribute(Attribute::NoAlias);

    if (PAttrBuilder.hasAttributes())
      Attrs.push_back(AttributeSet::get(Context, ArgTys.size(), PAttrBuilder));
  }

  PAL = AttributeSet::get(Context, Attrs);
  return FunctionType::get(RetTy, ArgTys, false);
}

FunctionType *
ConvertFunctionType(tree type, tree decl, tree static_chain,
                    CallingConv::ID &CallingConv, AttributeSet &PAL) {
  Type *RetTy = Type::getVoidTy(Context);
  SmallVector<Type *, 8> ArgTypes;
  FunctionTypeConversion Client(RetTy, ArgTypes, CallingConv,
                                false /*not K&R*/);
  DefaultABI ABIConverter(Client);

// Allow the target to set the CC for things like fastcall etc.
#ifdef TARGET_ADJUST_LLVM_CC
  TARGET_ADJUST_LLVM_CC(CallingConv, type);
#endif

  ABIConverter.HandleReturnType(TREE_TYPE(type), current_function_decl,
                                decl ? DECL_BUILT_IN(decl) : false);

  // Compute attributes for return type (and function attributes).
  SmallVector<AttributeSet, 8> Attrs;
  AttrBuilder FnAttrBuilder;

  int flags = flags_from_decl_or_type(decl ? decl : type);

  // Check for 'readnone' and 'readonly' function attributes.
  if (flags & ECF_CONST)
    FnAttrBuilder.addAttribute(Attribute::ReadNone);
  else if (flags & ECF_PURE)
    FnAttrBuilder.addAttribute(Attribute::ReadOnly);

  // TODO: Handle ECF_LOOPING_CONST_OR_PURE

  // Check for 'noreturn' function attribute.
  if (flags & ECF_NORETURN)
    FnAttrBuilder.addAttribute(Attribute::NoReturn);

  // Check for 'nounwind' function attribute.
  if (flags & ECF_NOTHROW)
    FnAttrBuilder.addAttribute(Attribute::NoUnwind);

  // Check for 'returnstwice' function attribute.
  if (flags & ECF_RETURNS_TWICE)
    FnAttrBuilder.addAttribute(Attribute::ReturnsTwice);

  // Since they write the return value through a pointer,
  // 'sret' functions cannot be 'readnone' or 'readonly'.
  if (ABIConverter.isShadowReturn()) {
    FnAttrBuilder.removeAttribute(Attribute::ReadNone)
        .removeAttribute(Attribute::ReadOnly);
  }

  // Demote 'readnone' nested functions to 'readonly' since
  // they may need to read through the static chain.
  if (static_chain && FnAttrBuilder.contains(Attribute::ReadNone)) {
    FnAttrBuilder.removeAttribute(Attribute::ReadNone);
    FnAttrBuilder.addAttribute(Attribute::ReadOnly);
  }

  // Compute whether the result needs to be zext or sext'd.
  LLVMContext &Context = RetTy->getContext();
  AttrBuilder RAttrBuilder;
  HandleArgumentExtension(TREE_TYPE(type), RAttrBuilder);

// Allow the target to change the attributes.
#ifdef TARGET_ADJUST_LLVM_RETATTR
  TARGET_ADJUST_LLVM_RETATTR(type, RAttrBuilder);
#endif

  // The value returned by a 'malloc' function does not alias anything.
  if (flags & ECF_MALLOC)
    RAttrBuilder.addAttribute(Attribute::NoAlias);

  if (RAttrBuilder.hasAttributes())
    Attrs.push_back(
        AttributeSet::get(Context, AttributeSet::ReturnIndex, RAttrBuilder));

  // If this function returns via a shadow argument, the dest loc is passed
  // in as a pointer.  Mark that pointer as struct-ret and noalias.
  if (ABIConverter.isShadowReturn()) {
    AttrBuilder B;
    B.addAttribute(Attribute::StructRet).addAttribute(Attribute::NoAlias);
    Attrs.push_back(AttributeSet::get(Context, ArgTypes.size(), B));
  }

  std::vector<Type *> ScalarArgs;
  if (static_chain) {
    // Pass the static chain as the first parameter.
    ABIConverter.HandleArgument(TREE_TYPE(static_chain), ScalarArgs);
    // Mark it as the chain argument.
    Attrs.push_back(
        AttributeSet::get(Context, ArgTypes.size(), Attribute::Nest));
  }

#ifdef LLVM_TARGET_ENABLE_REGPARM
  // If the target has regparam parameters, allow it to inspect the function
  // type.
  int local_regparam = 0;
  int local_fp_regparam = 0;
  LLVM_TARGET_INIT_REGPARM(local_regparam, local_fp_regparam, type);
#endif // LLVM_TARGET_ENABLE_REGPARM

  // Keep track of whether we see a byval argument.
  bool HasByVal = false;

  // Check if we have a corresponding decl to inspect.
  tree DeclArgs = (decl) ? DECL_ARGUMENTS(decl) : NULL;
  // Loop over all of the arguments, adding them as we go.
  tree Args = TYPE_ARG_TYPES(type);
  for (; Args && TREE_VALUE(Args) != void_type_node; Args = TREE_CHAIN(Args)) {
    tree ArgTy = TREE_VALUE(Args);
    if (!isPassedByInvisibleReference(ArgTy))
      if (const StructType *STy = dyn_cast<StructType>(ConvertType(ArgTy)))
        if (STy->isOpaque()) {
          // If we are passing an opaque struct by value, we don't know how many
          // arguments it will turn into.  Because we can't handle this yet,
          // codegen the prototype as (...).
          if (CallingConv == CallingConv::C)
            ArgTypes.clear();
          else
            // Don't nuke last argument.
            ArgTypes.erase(ArgTypes.begin() + 1, ArgTypes.end());
          Args = 0;
          break;
        }

    // Determine if there are any attributes for this param.
    AttrBuilder PAttrBuilder;

    unsigned OldSize = ArgTypes.size();

    ABIConverter.HandleArgument(ArgTy, ScalarArgs, &PAttrBuilder);

    // Compute zext/sext attributes.
    HandleArgumentExtension(ArgTy, PAttrBuilder);

    // Compute noalias attributes. If we have a decl for the function
    // inspect it for restrict qualifiers, otherwise try the argument
    // types.
    tree RestrictArgTy = (DeclArgs) ? TREE_TYPE(DeclArgs) : ArgTy;
    if (isa<ACCESS_TYPE>(RestrictArgTy) && TYPE_RESTRICT(RestrictArgTy))
      PAttrBuilder.addAttribute(Attribute::NoAlias);

#ifdef LLVM_TARGET_ENABLE_REGPARM
    // Allow the target to mark this as inreg.
    if (isa<INTEGRAL_TYPE>(ArgTy) || isa<ACCESS_TYPE>(ArgTy) ||
        isa<REAL_TYPE>(ArgTy))
      LLVM_ADJUST_REGPARM_ATTRIBUTE(PAttrBuilder, ArgTy,
                                    TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)),
                                    local_regparam, local_fp_regparam);
#endif // LLVM_TARGET_ENABLE_REGPARM

    if (PAttrBuilder.hasAttributes()) {
      HasByVal |= PAttrBuilder.contains(Attribute::ByVal);

      // If the argument is split into multiple scalars, assign the
      // attributes to all scalars of the aggregate.
      for (unsigned i = OldSize + 1; i <= ArgTypes.size(); ++i)
        Attrs.push_back(AttributeSet::get(Context, i, PAttrBuilder));
    }

    if (DeclArgs)
      DeclArgs = TREE_CHAIN(DeclArgs);
  }

  // If there is a byval argument then it is not safe to mark the function
  // 'readnone' or 'readonly': gcc permits a 'const' or 'pure' function to
  // write to struct arguments passed by value, but in LLVM this becomes a
  // write through the byval pointer argument, which LLVM does not allow for
  // readonly/readnone functions.
  if (HasByVal)
    FnAttrBuilder.removeAttribute(Attribute::ReadNone)
        .removeAttribute(Attribute::ReadOnly);

  assert(RetTy && "Return type not specified!");

  if (FnAttrBuilder.hasAttributes())
    Attrs.push_back(
        AttributeSet::get(Context, AttributeSet::FunctionIndex, FnAttrBuilder));

  // Finally, make the function type and result attributes.
  PAL = AttributeSet::get(Context, Attrs);
  return FunctionType::get(RetTy, ArgTypes, Args == 0);
}

static Type *ConvertPointerTypeRecursive(tree type) {
  // This is where self-recursion loops are broken, by not converting the type
  // pointed to if this would cause trouble (the pointer type is turned into
  // {}* instead).
  tree pointee = main_type(type);

  // The pointer type is in the strongly connected component (SCC) currently
  // being converted.  Check whether the pointee is as well.  If there is more
  // than one type in the SCC then necessarily the pointee type is in the SCC
  // since any path from the pointer type to the other type necessarily passes
  // via the pointee.  If the pointer type is the only element of the SCC then
  // the pointee is only in the SCC if it is equal to the pointer.
  bool bothInSCC = SCCInProgress->size() != 1 || pointee == type;

  Type *PointeeTy;
  if (!bothInSCC) {
    // It is safe to convert the pointee.  This is the common case, as we get
    // here for pointers to integers and so on.
    PointeeTy = ConvertType(pointee);
    if (PointeeTy->isVoidTy())
      PointeeTy = GetUnitType(Context); // void* -> byte*.
  } else {
    // Both the pointer and the pointee type are in the SCC so it is not safe
    // to convert the pointee type - otherwise we would get an infinite loop.
    // However if a type, for example an opaque struct placeholder, has been
    // registered for the pointee then we can return a pointer to it, giving
    // nicer IR (this is not needed for correctness).  Note that some members
    // of the SCC may have been converted already at this point (for this to
    // happen there must be more than one pointer type in the SCC), and thus
    // will have LLVM types registered for them.  Unfortunately which types
    // have been converted depends on the order in which we visit the SCC, and
    // that is not an intrinsic property of the SCC.  This is why we choose to
    // only use the types registered for records and unions - these are always
    // available.  As a further attempt to improve the IR, we return an S* for
    // an array type S[N] if (recursively) S is a record or union type.

    // Drill down through nested arrays to the ultimate element type.  Thanks
    // to this we may return S* for a (S[])*, which is better than {}*.
    while (isa<ARRAY_TYPE>(pointee))
      pointee = main_type(pointee);

    // If the pointee is a record or union type then return a pointer to its
    // placeholder type.  Otherwise return {}*.
    if (isa<RECORD_OR_UNION_TYPE>(pointee))
      PointeeTy = getCachedType(pointee);
    else
      PointeeTy = StructType::get(Context);
  }

  return PointeeTy->getPointerTo(TYPE_ADDR_SPACE(type));
}

typedef Range<uint64_t> BitRange;

/// TypedRange - A type that applies to a range of bits.  Any part of the type
/// outside of the range is discarded.  The range may be bigger than the type
/// in which case any extra bits have an undefined type.
namespace {

class TypedRange {
  BitRange R;      // The range of bits occupied by the type.
  Type *Ty;        // The type.  May be null if the range is empty.
  uint64_t Starts; // The first bit of the type is positioned at this offset.

  TypedRange(BitRange r, Type *t, uint64_t starts)
      : R(r), Ty(t), Starts(starts) {
    assert((R.empty() || Ty) && "Need type when range not empty!");
  }

  /// isSafeToReturnContentsDirectly - Return whether the current value for the
  /// type properly represents the bits in the range and so can be handed to the
  /// user as is.
  bool isSafeToReturnContentsDirectly(const DataLayout &DL) const {
    // If there is no type (allowed when the range is empty) then one needs to
    // be created.
    if (!Ty)
      return false;
    // If the first bit of the type is not the first bit of the range then it
    // needs to be displaced before being passed to the user.
    if (!R.empty() && R.getFirst() != Starts)
      return false;
    // Check that the type isn't something like i17.  Avoiding types like this
    // is not needed for correctness, but makes life easier for the optimizers.
    if ((Ty->getPrimitiveSizeInBits() % BITS_PER_UNIT) != 0)
      return false;
    // If the type is wider than the range then it needs to be truncated before
    // being passed to the user.
    uint64_t AllocBits = DL.getTypeAllocSizeInBits(Ty);
    return AllocBits <= R.getWidth();
  }

public:
  /// get - Use the given type for the range [first, last).
  static TypedRange get(uint64_t first, uint64_t last, Type *Ty) {
    return TypedRange(BitRange(first, last), Ty, first);
  }

  // Copy assignment operator.
  TypedRange &operator=(const TypedRange & other) {
    R = other.R;
    Ty = other.Ty;
    Starts = other.Starts;
    return *this;
  }

  /// getRange - Return the range occupied by this field.
  BitRange getRange() const { return R; }

  /// ChangeRangeTo - Change the range occupied by this field.
  void ChangeRangeTo(BitRange r) { R = r; }

  /// JoinWith - Form the union of this field with another field (which must be
  /// disjoint from this one).  After this the range will be the convex hull of
  /// the ranges of the two fields.
  void JoinWith(const TypedRange &S);

  /// extractContents - Return the contained bits as a type which covers every
  /// defined bit in the range, yet is guaranteed to have alloc size no larger
  /// than the width of the range.  Unlike the other methods for this class this
  /// one requires that the width of the range be a multiple of an address unit,
  /// which usually means a multiple of 8.
  Type *extractContents(const DataLayout &DL) {
    assert(R.getWidth() % BITS_PER_UNIT == 0 && "Boundaries not aligned?");
    /// If the current value for the type can be used to represent the bits in
    /// the range then just return it.
    if (isSafeToReturnContentsDirectly(DL))
      return Ty;
    // If the range is empty then return a type with zero size.
    if (R.empty()) {
      // Return an empty array.  Remember the returned value as an optimization
      // in case we are called again.
      Ty = GetUnitType(Context, 0);
      assert(isSafeToReturnContentsDirectly(DL) && "Unit over aligned?");
      return Ty;
    }
    // If the type is something like i17 then round it up to a multiple of a
    // byte.  This is not needed for correctness, but helps the optimizers.
    if ((Ty->getPrimitiveSizeInBits() % BITS_PER_UNIT) != 0) {
      unsigned BitWidth =
          RoundUpToAlignment(Ty->getPrimitiveSizeInBits(), BITS_PER_UNIT);
      Ty = IntegerType::get(Context, BitWidth);
      if (isSafeToReturnContentsDirectly(DL))
        return Ty;
    }
    // Represent the range using an array of bytes.  Remember the returned type
    // as an optimization in case we are called again.
    // TODO: If the type only needs to be truncated and has struct or array type
    // then we could try to do the truncation by dropping or modifying the last
    // elements of the type, maybe yielding something less horrible.
    uint64_t Units = R.getWidth() / BITS_PER_UNIT;
    Ty = GetUnitType(Context, Units);
    Starts = R.getFirst();
    assert(isSafeToReturnContentsDirectly(DL) && "Unit over aligned?");
    return Ty;
  }
};

} // Unnamed namespace.

/// JoinWith - Form the union of this field with another field (which must be
/// disjoint from this one).  After this the range will be the convex hull of
/// the ranges of the two fields.
void TypedRange::JoinWith(const TypedRange &S) {
  if (S.R.empty())
    return;
  if (R.empty()) {
    *this = S;
    return;
  }
  // Use an integer type that covers both ranges.  Turning everything into an
  // integer like this is pretty nasty, but as we only get here for bitfields
  // it is fairly harmless.
  R = R.Join(S.R);
  Ty = IntegerType::get(Context, R.getWidth());
  Starts = R.getFirst();
}

static Type *ConvertRecordTypeRecursive(tree type) {
  // FIXME: This new logic, especially the handling of bitfields, is untested
  // and probably wrong on big-endian machines.
  assert(TYPE_SIZE(type) && "Incomplete types should be handled elsewhere!");

  IntervalList<TypedRange, uint64_t, 8> Layout;
  const DataLayout &DL = getDataLayout();

  // Get the size of the type in bits.  If the type has variable or ginormous
  // size then it is convenient to pretend it is "infinitely" big.
  uint64_t TypeSize =
      isInt64(TYPE_SIZE(type), true) ? getInt64(TYPE_SIZE(type), true) : ~0UL;

  // Record all interesting fields so they can easily be visited backwards.
  SmallVector<tree, 16> Fields;
  for (tree field = TYPE_FIELDS(type); field; field = TREE_CHAIN(field)) {
    if (!isa<FIELD_DECL>(field))
      continue;
    // Ignore fields with variable or unknown position since they cannot be
    // represented by the LLVM type system.
    if (!OffsetIsLLVMCompatible(field))
      continue;
    Fields.push_back(field);
  }

  // Process the fields in reverse order.  This is for the benefit of union
  // types since it means that a zero constant of the LLVM type will fully
  // initialize the first union member, which is needed if the zero constant
  // is to be used as the default value for the union type.
  for (SmallVector<tree, 16>::reverse_iterator I = Fields.rbegin(),
                                               E = Fields.rend();
       I != E; ++I) {
    tree field = *I;
    uint64_t FirstBit = getFieldOffsetInBits(field);
    assert(FirstBit <= TypeSize && "Field off end of type!");
    // Determine the width of the field.
    uint64_t BitWidth;
    Type *FieldTy = ConvertType(TREE_TYPE(field));
    if (isInt64(DECL_SIZE(field), true)) {
      // The field has a size and it is a constant, so use it.  Note that
      // this size may be smaller than the type size.  For example, if the
      // next field starts inside alignment padding at the end of this one
      // then DECL_SIZE will be the size with the padding used by the next
      // field not included.
      BitWidth = getInt64(DECL_SIZE(field), true);
    } else {
      // If the field has variable or unknown size then use the size of the
      // LLVM type instead as it gives the minimum size the field may have.
      assert(FieldTy->isSized() && "Type field has no size!");
      BitWidth = DL.getTypeAllocSizeInBits(FieldTy);
      if (FirstBit + BitWidth > TypeSize)
        BitWidth = TypeSize - FirstBit;
    }
    uint64_t LastBit = FirstBit + BitWidth;

    if (LastBit > TypeSize) {
      // Qualified union types may list fields that cannot be present, but that
      // the optimizers weren't smart enough to remove.  It can sometimes happen
      // that the optimizers nonetheless managed to simplify the type size to a
      // constant, which can be smaller than the size of the non-present fields
      // if were larger than the rest.
      assert(isa<QUAL_UNION_TYPE>(type) && "Field runs off end of type!");
      LastBit = TypeSize;
    }

    // Set the type of the range of bits occupied by the field to the LLVM type
    // for the field.
    Layout.AddInterval(TypedRange::get(FirstBit, LastBit, FieldTy));
  }

  // Force all fields to begin and end on a byte boundary.  This automagically
  // takes care of bitfields.
  Layout.AlignBoundaries(BITS_PER_UNIT);

  // Determine whether to return a packed struct type.  If returning an ordinary
  // struct would result in a type that is more aligned than the GCC type then
  // return a packed struct instead.  If a field's alignment would make it start
  // after its desired position then also use a packed struct type.
  bool Pack = false;
  unsigned MaxAlign = TYPE_ALIGN(type);
  for (unsigned i = 0, e = Layout.getNumIntervals(); i != e; ++i) {
    TypedRange F = Layout.getInterval(i);
    uint64_t First = F.getRange().getFirst();
    Type *Ty = F.extractContents(DL);
    unsigned Alignment = DL.getABITypeAlignment(Ty) * 8;
    if (Alignment > MaxAlign || First % Alignment) {
      Pack = true;
      break;
    }
  }

  // Create the elements that will make up the struct type.  As well as the
  // fields themselves there may also be padding elements.
  std::vector<Type *> Elts;
  Elts.reserve(Layout.getNumIntervals());
  uint64_t EndOfPrevious = 0; // Offset of first bit after previous element.
  for (unsigned i = 0, e = Layout.getNumIntervals(); i != e; ++i) {
    TypedRange F = Layout.getInterval(i);
    uint64_t First = F.getRange().getFirst();
    Type *Ty = F.extractContents(DL);
    assert(EndOfPrevious <= First && "Previous field too big!");

    // If there is a gap then we may need to fill it with padding.
    if (First > EndOfPrevious) {
      // There is a gap between the end of the previous field and the start of
      // this one.  The alignment of the field contents may mean that it will
      // start at the right offset anyway, but if not then insert padding.
      bool NeedPadding = true;
      if (!Pack) {
        // If the field's alignment will take care of the gap then there is no
        // need for padding.
        unsigned Alignment = DL.getABITypeAlignment(Ty) * 8;
        if (First == (EndOfPrevious + Alignment - 1) / Alignment * Alignment)
          NeedPadding = false;
      }
      if (NeedPadding) {
        // Fill the gap with an array of bytes.
        assert((First - EndOfPrevious) % BITS_PER_UNIT == 0 &&
               "Non-unit field boundaries!");
        uint64_t Units = (First - EndOfPrevious) / BITS_PER_UNIT;
        Elts.push_back(GetUnitType(Context, Units));
      }
    }

    // Append the field.
    Elts.push_back(Ty);
    EndOfPrevious = First + DL.getTypeAllocSizeInBits(Ty);
  }

  // If the GCC type has a sensible size then we guarantee that LLVM type has
  // the same size.  If needed, append padding to ensure this.
  if (TypeSize != ~0UL && EndOfPrevious < TypeSize) {
    assert((TypeSize - EndOfPrevious) % BITS_PER_UNIT == 0 &&
           "Non-unit type size?");
    uint64_t Units = (TypeSize - EndOfPrevious) / BITS_PER_UNIT;
    Elts.push_back(GetUnitType(Context, Units));
  }

  // OK, we're done.  Add the fields to the struct type and return it.
  Type *STy = getCachedType(type);
  assert(STy && isa<StructType>(STy) && cast<StructType>(STy)->isOpaque() &&
         "Incorrect placeholder for struct type!");
  cast<StructType>(STy)->setBody(Elts, Pack);
  return STy;
}

static Type *ConvertVectorTypeRecursive(tree type) {
  Type *EltTy = ConvertType(TREE_TYPE(type));
  return VectorType::get(EltTy, TYPE_VECTOR_SUBPARTS(type));
}

/// mayRecurse - Return true if converting this type may require breaking a
/// self-referential type loop.  For example, converting the struct type
///   struct S;
///   struct S {
///     struct S* s;
///   };
/// requires converting the "struct S*" field type; converting that pointer
/// type requires converting "struct S", leading to an infinite loop.  On the
/// other hand simple types like integers are never self-referential.  As this
/// routine is intended to be quick and simple, it returns true when in doubt.
/// Note that if a complicated type has already been converted then false is
/// usually returned, since type conversion doesn't have to do anything except
/// return the previously computed LLVM type.  The exception is record or union
/// types which were first converted when incomplete but that are now complete
/// so need to be converted again.
static bool mayRecurse(tree type) {
  assert(type == TYPE_MAIN_VARIANT(type) && "Not converting the main variant!");
  switch (TREE_CODE(type)) {
  default:
    llvm_unreachable("Unknown type!");

  case BOOLEAN_TYPE:
  case ENUMERAL_TYPE:
  case FIXED_POINT_TYPE:
  case INTEGER_TYPE:
#if (GCC_MINOR > 5)
  case NULLPTR_TYPE:
#endif
  case OFFSET_TYPE:
  case REAL_TYPE:
  case VOID_TYPE:
    // Simple types that are never self-referential.
    return false;

  case COMPLEX_TYPE:
    // Converting this type does involve converting another type, however that
    // conversion cannot refer back to the initial type.
    return false;

  case VECTOR_TYPE:
    // If this is a vector of pointers then the pointer could refer back to the
    // vector, but this can only cause recursion if the vector was not converted
    // yet.
    return isa<ACCESS_TYPE>(TREE_TYPE(type)) && getCachedType(type) == 0;

  case ARRAY_TYPE:
  case FUNCTION_TYPE:
  case METHOD_TYPE:
  case POINTER_TYPE:
  case REFERENCE_TYPE:
    // Converting these types may recurse unless the type was already converted.
    return getCachedType(type) == 0;

  case QUAL_UNION_TYPE:
  case RECORD_TYPE:
  case UNION_TYPE: {
    // Converting these types may recurse unless already converted.  However if
    // the type was converted when still incomplete but is now complete then it
    // needs to be converted again, which might recurse.

    // If the type is incomplete then converting it will not recurse (conversion
    // just returns an opaque type).
    if (!TYPE_SIZE(type))
      return false;

    // If the type was not previously converted then converting it may recurse.
    Type *Ty = getCachedType(type);
    if (!Ty)
      return true;

    // If the type was previously converted when incomplete then converting it
    // may recurse as the type is now complete so needs to be converted again.
    if (cast<StructType>(Ty)->isOpaque())
      return true;

    // The type was already converted and does not need to be converted again.
    return false;
  }
  }
}

/// ConvertTypeRecursive - Convert a type when conversion may require breaking
/// type conversion loops, see mayRecurse.  Note that all types used by but not
/// in the current strongly connected component (SCC) must have been converted
/// already.
static Type *ConvertTypeRecursive(tree type) {
  assert(type == TYPE_MAIN_VARIANT(type) && "Not converting the main variant!");
  assert(mayRecurse(type) && "Expected a recursive type!");
  assert(SCCInProgress && "Missing recursion data!");

#ifndef NDEBUG
  // Check that the given type is in the current strongly connected component
  // (SCC) of the type graph.  This should always be the case because SCCs are
  // visited bottom up.
  bool inSCC = false;
  for (size_t i = 0, e = SCCInProgress->size(); i != e; ++i)
    if ((*SCCInProgress)[i] == type) {
      inSCC = true;
      break;
    }
  if (!inSCC) {
    debug_tree(type);
    llvm_unreachable("Type not in SCC!");
  }
#endif

  switch (TREE_CODE(type)) {
  default:
    debug_tree(type);
    llvm_unreachable("Unexpected type!");

  case ARRAY_TYPE:
    return RememberTypeConversion(type, ConvertArrayTypeRecursive(type));

  case FUNCTION_TYPE:
  case METHOD_TYPE: {
    CallingConv::ID CallingConv;
    AttributeSet PAL;
    // No declaration to pass through, passing NULL.
    return RememberTypeConversion(
        type, ConvertFunctionType(type, NULL, NULL, CallingConv, PAL));
  }

  case POINTER_TYPE:
  case REFERENCE_TYPE:
    return RememberTypeConversion(type, ConvertPointerTypeRecursive(type));

  case RECORD_TYPE:
  case UNION_TYPE:
  case QUAL_UNION_TYPE:
    return RememberTypeConversion(type, ConvertRecordTypeRecursive(type));

  case VECTOR_TYPE:
    return RememberTypeConversion(type, ConvertVectorTypeRecursive(type));
  }
}

/// ConvertTypeNonRecursive - Convert a type when this is known to not require
/// breaking type conversion loops, see mayRecurse.
static Type *ConvertTypeNonRecursive(tree type) {
  assert(type == TYPE_MAIN_VARIANT(type) && "Not converting the main variant!");
  assert(!mayRecurse(type) && "Expected a non-recursive type!");

  // If we already converted the type, reuse the previous conversion.  Note that
  // this fires for types which are really recursive, such as pointer types, but
  // that we don't consider recursive any more because already converted.
  if (Type *Ty = getCachedType(type))
    return CheckTypeConversion(type, Ty);

  // Handle the void type early to avoid confusion with incomplete types below.
  if (isa<VOID_TYPE>(type))
    return RememberTypeConversion(type, Type::getVoidTy(Context));

  // Return a placeholder if the type is incomplete.
  if (!TYPE_SIZE(type)) {
    // Return a byte as the placeholder for incomplete enums.
    if (isa<ENUMERAL_TYPE>(type))
      return RememberTypeConversion(type, GetUnitType(Context));

    // Return an opaque struct for an incomplete record type.
    assert(isa<RECORD_OR_UNION_TYPE>(type) && "Unexpected incomplete type!");
    return RememberTypeConversion(
        type, StructType::create(Context, getDescriptiveName(type)));
  }

  // From here on we are only dealing with straightforward types.
  assert(isSizeCompatible(type) && "Funkily sized types should not get here!");
  uint64_t SizeInBits = getInt64(TYPE_SIZE(type), true);
  unsigned AlignInBits = TYPE_ALIGN(type);

  // Convert to the obvious LLVM type.
  Type *Ty;
  switch (TREE_CODE(type)) {
  default:
    debug_tree(type);
    llvm_unreachable("Unknown or recursive type!");

  case BOOLEAN_TYPE:
  case ENUMERAL_TYPE:
  case INTEGER_TYPE:
    Ty = IntegerType::get(Context, SizeInBits);
    break;

  case COMPLEX_TYPE: {
    Ty = ConvertTypeNonRecursive(main_type(type));
    Ty = StructType::get(Ty, Ty, NULL);
    break;
  }

#if (GCC_MINOR > 5)
  case NULLPTR_TYPE:
    Ty = GetUnitPointerType(Context, TYPE_ADDR_SPACE(type));
    break;
#endif

  case OFFSET_TYPE: {
    // Handle OFFSET_TYPE specially.  This is used for pointers to members,
    // which are really just integer offsets.  Return the appropriate integer
    // type directly.
    unsigned AS = TYPE_ADDR_SPACE(type);
    Ty = getDataLayout().getIntPtrType(Context, AS);
    break;
  }

  case REAL_TYPE:
    switch (TYPE_PRECISION(type)) {
    default:
      debug_tree(type);
      llvm_unreachable("Unknown FP type!");
    case 32:
      Ty = Type::getFloatTy(Context);
      break;
    case 64:
      Ty = Type::getDoubleTy(Context);
      break;
    case 80:
      Ty = Type::getX86_FP80Ty(Context);
      break;
    case 128:
#ifdef TARGET_POWERPC
      Ty = Type::getPPC_FP128Ty(Context);
#else
      // IEEE quad precision.
      Ty = Type::getFP128Ty(Context);
#endif
      break;
    }
    break;

  case VECTOR_TYPE: {
    assert(!isa<ACCESS_TYPE>(TREE_TYPE(type)) && "Type not already converted!");
    Ty = ConvertTypeNonRecursive(main_type(type));
    Ty = VectorType::get(Ty, TYPE_VECTOR_SUBPARTS(type));
    break;
  }
  }

  // If the LLVM type we chose has the wrong size or is overaligned then use a
  // bunch of bytes instead.
  assert(Ty->isSized() && "Must convert to a sized type!");
  uint64_t LLVMSizeInBits = getDataLayout().getTypeAllocSizeInBits(Ty);
  unsigned LLVMAlignInBits = getDataLayout().getABITypeAlignment(Ty) * 8;
  if (LLVMSizeInBits != SizeInBits || LLVMAlignInBits > AlignInBits)
    Ty = GetUnitType(Context, SizeInBits / BITS_PER_UNIT);

  return RememberTypeConversion(type, Ty);
}

/// RecursiveTypeIterator - A convenience class that visits only those nodes
/// in the type graph that mayRecurse thinks might be self-referential.  Note
/// that dereferencing returns the main variant of the contained type rather
/// than the contained type itself.  See ContainedTypeIterator and mayRecurse
/// for more information about the type graph and self-referential types.
namespace {

class RecursiveTypeIterator {
  // This class wraps an iterator that visits all contained types, and just
  // increments the iterator over any contained types that will not recurse.
  ContainedTypeIterator I;

  /// SkipNonRecursiveTypes - Increment the wrapped iterator over any types
  /// that mayRecurse says can be converted directly without having to worry
  /// about self-recursion.
  void SkipNonRecursiveTypes() {
    while (I != ContainedTypeIterator::end() &&
           !(isa<TYPE>(*I) && mayRecurse(TYPE_MAIN_VARIANT(*I))))
      ++I;
  }

  /// RecursiveTypeIterator - Convenience constructor for internal use.
  explicit RecursiveTypeIterator(const ContainedTypeIterator &i) : I(i) {}

public:

  /// Dereference operator returning the main variant of the contained type.
  tree operator*() { return TYPE_MAIN_VARIANT(*I); }
  ;

  /// Comparison operators.
  bool operator==(const RecursiveTypeIterator &other) const {
    return other.I == this->I;
  }
  bool operator!=(const RecursiveTypeIterator &other) const {
    return !(*this == other);
  }

  /// Postfix increment operator.
  RecursiveTypeIterator operator++(int) {
    RecursiveTypeIterator Result(*this);
    ++(*this);
    return Result;
  }

  /// Prefix increment operator.
  RecursiveTypeIterator &operator++() {
    ++I;
    SkipNonRecursiveTypes();
    return *this;
  }

  /// begin - Return an iterator referring to the first type contained in the
  /// given type.
  static RecursiveTypeIterator begin(tree type) {
    RecursiveTypeIterator R(ContainedTypeIterator::begin(type));
    R.SkipNonRecursiveTypes();
    return R;
  }

  /// end - Return the end iterator for contained type iteration.
  static RecursiveTypeIterator end() {
    return RecursiveTypeIterator(ContainedTypeIterator::end());
  }
};

} // Unnamed namespace.

// Traits for working with the graph of possibly self-referential type nodes,
// see RecursiveTypeIterator.
namespace llvm {
template <> struct GraphTraits<tree> {
  typedef tree_node NodeType;
  typedef RecursiveTypeIterator ChildIteratorType;
  static inline NodeType *getEntryNode(tree t) {
    assert(TYPE_P(t) && "Expected a type!");
    return t;
  }
  static inline ChildIteratorType child_begin(tree type) {
    return ChildIteratorType::begin(type);
  }
  static inline ChildIteratorType child_end(tree) {
    return ChildIteratorType::end();
  }
};
}

Type *ConvertType(tree type) {
  if (type == error_mark_node)
    return Type::getInt32Ty(Context);

  // Check that the type mode doesn't depend on the type variant (various bits
  // of the plugin rely on this).
  assert(TYPE_MODE(type) == TYPE_MODE(TYPE_MAIN_VARIANT(type)) &&
         "Type mode differs between variants!");

  // LLVM doesn't care about variants such as const, volatile, or restrict.
  type = TYPE_MAIN_VARIANT(type);

  // If this type can be converted without special action being needed to avoid
  // conversion loops coming from self-referential types, then convert it.
  if (!mayRecurse(type))
    return ConvertTypeNonRecursive(type);

  // If we already started a possibly looping type conversion, continue with it.
  if (SCCInProgress)
    return ConvertTypeRecursive(type);

  // Begin converting a type for which the conversion may require breaking type
  // conversion loops coming from self-referential types, see mayRecurse.  First
  // analyse all of the types that will need to be converted in order to convert
  // this one, finding sets of types that must be converted simultaneously (i.e.
  // for which converting any one of them requires converting all of the others;
  // these sets are the strongly connected components (SCCs) of the type graph),
  // then visit them bottom up, converting all types in them.  "Bottom up" means
  // that if a type in a SCC makes use of a type T that is not in the SCC then T
  // will be visited first.  Note that this analysis is performed only once: the
  // results of the type conversion are cached, and any future conversion of one
  // of the visited types will just return the cached value.
  for (scc_iterator<tree> I = scc_begin(type), E = scc_end(type); I != E; ++I) {
    const std::vector<tree> &SCC = *I;

    // First create a placeholder opaque struct for every record or union type
    // in the SCC.  This way, if we have both "struct S" and "struct S*" in the
    // SCC then we can return an LLVM "%struct.s*" for the pointer rather than
    // the nasty {}* type we are obliged to return in general.
    for (size_t i = 0, e = SCC.size(); i != e; ++i) {
      tree some_type = SCC[i];
      if (!isa<RECORD_OR_UNION_TYPE>(some_type)) {
        assert(!getCachedType(some_type) && "Type already converted!");
        continue;
      }
      // If the type used to be incomplete then a opaque struct placeholder may
      // have been created for it already.
      Type *Ty = getCachedType(some_type);
      if (Ty) {
        assert(isa<StructType>(Ty) && cast<StructType>(Ty)->isOpaque() &&
               "Recursive struct already fully converted!");
        continue;
      }
      // Otherwise register a placeholder for this type.
      Ty = StructType::create(Context, getDescriptiveName(some_type));
      // Associate the placeholder with the GCC type without sanity checking
      // since the type sizes won't match yet.
      setCachedType(some_type, Ty);
    }

    // Now convert every type in the SCC, filling in the placeholders created
    // above.  In the common case there is only one type in the SCC, meaning
    // that the type turned out not to be self-recursive and can be converted
    // without having to worry about type conversion loops.  If there is more
    // than one type in the SCC then self-recursion is overcome by returning
    // {}* for the pointer types if nothing better can be done.  As back edges
    // in the type graph can only be created by pointer types, "removing" such
    // edges like this destroys all cycles allowing the other types in the SCC
    // to be converted straightforwardly.
    SCCInProgress = &SCC;
    for (size_t i = 0, e = SCC.size(); i != e; ++i)
      ConvertType(SCC[i]);
    SCCInProgress = 0;

    // Finally, replace pointer types with a pointer to the pointee type (which
    // has now been computed).  This means that while uses of the pointer type
    // by types in the SCC will most likely have been converted into nasty {}*,
    // uses by types outside the SCC will see a sensible pointer type.  This is
    // not needed for correctness - it just makes the IR nicer.
    if (SCC.size() > 1)
      for (size_t i = 0, e = SCC.size(); i != e; ++i) {
        tree some_type = SCC[i];
        if (isa<ACCESS_TYPE>(some_type)) {
          tree pointee = main_type(some_type);
          // The pointee cannot have void type since the SCC contains more than
          // one type.
          assert(!isa<VOID_TYPE>(pointee) && "Self-recursive void*!");
          // The pointee must have been converted since it has to be in the same
          // SCC as the pointer (since the SCC contains more than one type).
          Type *PointeeTy = getCachedType(pointee);
          assert(PointeeTy && "Pointee not converted!");
          unsigned AS = TYPE_ADDR_SPACE(some_type);
          RememberTypeConversion(some_type, PointeeTy->getPointerTo(AS));
        }
      }
  }

  // At this point every type reachable from this one has been converted, and
  // the conversion results cached.  Return the value computed for the type.
  Type *Ty = getCachedType(type);
  assert(Ty && "Type not converted!");
  return Ty;
}