Fix a bug with curried function emission and teach the mangler

rjmccall · rjmccall · commit 9c63d1e7e6bd · 2012-01-17T08:08:47.000Z
to differentiate uncurried and curried function types.



Swift SVN r1059
diff --git a/lib/IRGen/GenFunc.cpp b/lib/IRGen/GenFunc.cpp
@@ -95,6 +95,20 @@ static unsigned getNaturalUncurryLevel(FuncDecl *func) {
   return count - 1;
 }
 
+/// Given a function type, return the formal result type at the given
+/// uncurrying level.  For 'a -> b -> c', this is 'b' at 0 and 'c' at 1.
+static Type getResultType(Type type, unsigned uncurryLevel) {
+  do {
+    type = type->castTo<FunctionType>()->Result;
+  } while (uncurryLevel--);
+  return type;
+}
+
+const TypeInfo &IRGenFunction::getResultTypeInfo() const {
+  Type resultType = getResultType(CurFuncExpr->getType(), CurUncurryLevel);
+  return IGM.getFragileTypeInfo(resultType);
+}
+
 namespace {
   /// A signature represents something which can actually be called.
   class Signature {
@@ -770,20 +784,17 @@ void IRGenFunction::emitPrologue() {
   CurFn->getBasicBlockList().push_back(ReturnBB);
 
   // Copy over the arguments as an Explosion.
-  Explosion args(ExplosionKind::Minimal);
+  Explosion args(CurExplosionLevel);
   for (auto i = CurFn->arg_begin(), e = CurFn->arg_end(); i != e; ++i) {
     args.add(i);
   }
 
   // Set up the return slot, stealing the first argument if necessary.
   {
     // Find the 'code' result type of this function.
-    FunctionType *fnType = CurFuncExpr->getType()->castTo<FunctionType>();
-    while (FunctionType *fnResult = dyn_cast<FunctionType>(fnType->Result))
-      fnType = fnResult;
-    const TypeInfo &resultType = IGM.getFragileTypeInfo(fnType->Result);
+    const TypeInfo &resultType = getResultTypeInfo();
 
-    ExplosionSchema resultSchema(args.getKind());
+    ExplosionSchema resultSchema(CurExplosionLevel);
     resultType.getExplosionSchema(resultSchema);
 
     if (requiresAggregateResult(resultSchema)) {
@@ -865,26 +876,26 @@ void IRGenFunction::emitEpilogue() {
     Builder.SetInsertPoint(ReturnBB);
   }
 
-  FunctionType *FnTy = CurFuncExpr->getType()->castTo<FunctionType>();
-  assert(FnTy && "emitting a declaration that's not a function?");
+  const TypeInfo &resultType = getResultTypeInfo();
+  ExplosionSchema resultSchema(CurExplosionLevel);
+  resultType.getExplosionSchema(resultSchema);
 
-  const TypeInfo &resultType = IGM.getFragileTypeInfo(FnTy->Result);
-  RValueSchema resultSchema = resultType.getSchema();
-  if (resultSchema.isAggregate()) {
+  if (requiresAggregateResult(resultSchema)) {
     assert(isa<llvm::Argument>(ReturnSlot.getAddress()));
     Builder.CreateRetVoid();
-  } else if (resultSchema.isScalar(0)) {
+  } else if (resultSchema.empty()) {
     assert(!ReturnSlot.isValid());
     Builder.CreateRetVoid();
   } else {
-    RValue RV = resultType.load(*this, ReturnSlot);
-    if (RV.isScalar(1)) {
-      Builder.CreateRet(RV.getScalars()[0]);
+    Explosion result(CurExplosionLevel);
+    resultType.loadExplosion(*this, ReturnSlot, result);
+    if (result.size() == 1) {
+      Builder.CreateRet(result.claimNext());
     } else {
-      llvm::Value *Result = llvm::UndefValue::get(CurFn->getReturnType());
-      for (unsigned I = 0, E = RV.getScalars().size(); I != E; ++I)
-        Result = Builder.CreateInsertValue(Result, RV.getScalars()[I], I);
-      Builder.CreateRet(Result);
+      llvm::Value *resultAgg = llvm::UndefValue::get(CurFn->getReturnType());
+      for (unsigned i = 0, e = result.size(); i != e; ++i)
+        resultAgg = Builder.CreateInsertValue(resultAgg, result.claimNext(), i);
+      Builder.CreateRet(resultAgg);
     }
   }
 }
@@ -896,12 +907,15 @@ void IRGenModule::emitGlobalFunction(FuncDecl *func) {
 
   // FIXME: variant currying levels!
   // FIXME: also emit entrypoints with maximal explosion when all types are known!
+  unsigned uncurryLevel = getNaturalUncurryLevel(func);
+  ExplosionKind explosionLevel = ExplosionKind::Minimal;
 
-  llvm::Function *addr = getAddrOfGlobalFunction(func, ExplosionKind::Minimal,
-                                                 getNaturalUncurryLevel(func));
+  llvm::Function *addr =
+    getAddrOfGlobalFunction(func, explosionLevel, uncurryLevel);
 
   FuncExpr *funcExpr = cast<FuncExpr>(func->getInit());
-  IRGenFunction(*this, funcExpr, addr).emitFunctionTopLevel(funcExpr->getBody());
+  IRGenFunction(*this, funcExpr, explosionLevel, uncurryLevel, addr)
+    .emitFunctionTopLevel(funcExpr->getBody());
 }
 
 void IRGenFunction::emitFunctionTopLevel(BraceStmt *S) {
diff --git a/lib/IRGen/GenGlobal.cpp b/lib/IRGen/GenGlobal.cpp
@@ -66,7 +66,8 @@ void IRGenModule::emitTranslationUnit(TranslationUnit *tunit) {
                 nullptr, tunit);
 
   llvm::Function *fn = createGlobalInitFunction(*this, tunit);
-  IRGenFunction(*this, &func, fn).emitGlobalTopLevel(tunit->Body);
+  IRGenFunction(*this, &func, ExplosionKind::Minimal, /*uncurry*/ 0, fn)
+    .emitGlobalTopLevel(tunit->Body);
 
   // Not all translation units need a global initialization function.
   if (isTrivialGlobalInit(fn)) {
diff --git a/lib/IRGen/IRGenFunction.cpp b/lib/IRGen/IRGenFunction.cpp
@@ -25,8 +25,11 @@
 using namespace swift;
 using namespace irgen;
 
-IRGenFunction::IRGenFunction(IRGenModule &IGM, FuncExpr *FE, llvm::Function *Fn)
-  : IGM(IGM), Builder(IGM.getLLVMContext()), CurFuncExpr(FE), CurFn(Fn) {
+IRGenFunction::IRGenFunction(IRGenModule &IGM, FuncExpr *FE,
+                             ExplosionKind explosionLevel,
+                             unsigned uncurryLevel, llvm::Function *Fn)
+  : IGM(IGM), Builder(IGM.getLLVMContext()), CurFuncExpr(FE), CurFn(Fn),
+    CurExplosionLevel(explosionLevel), CurUncurryLevel(uncurryLevel) {
   emitPrologue();
 }
 
diff --git a/lib/IRGen/IRGenFunction.h b/lib/IRGen/IRGenFunction.h
@@ -53,6 +53,7 @@ namespace swift {
 namespace irgen {
   class Condition;
   class Explosion;
+  enum class ExplosionKind : unsigned;
   class IRGenModule;
   class JumpDest;
   class LValue;
@@ -68,8 +69,11 @@ class IRGenFunction {
 
   FuncExpr *CurFuncExpr;
   llvm::Function *CurFn;
+  ExplosionKind CurExplosionLevel;
+  unsigned CurUncurryLevel;
 
-  IRGenFunction(IRGenModule &IGM, FuncExpr *FE, llvm::Function *Fn);
+  IRGenFunction(IRGenModule &IGM, FuncExpr *FE, ExplosionKind explosion,
+                unsigned uncurryLevel, llvm::Function *fn);
   ~IRGenFunction();
 
   void unimplemented(SourceLoc Loc, StringRef Message);
@@ -88,6 +92,7 @@ class IRGenFunction {
   Address ReturnSlot;
   llvm::BasicBlock *ReturnBB;
   JumpDest getReturnDest();
+  const TypeInfo &getResultTypeInfo() const;
 
 //--- Helper methods -----------------------------------------------------------
 public:
diff --git a/lib/IRGen/Mangle.cpp b/lib/IRGen/Mangle.cpp
@@ -24,6 +24,7 @@
 
 #include "IRGenModule.h"
 #include "Linking.h"
+#include "IRGen.h"
 
 using namespace swift;
 using namespace irgen;
@@ -58,7 +59,7 @@ namespace {
   public:
     Mangler(raw_ostream &buffer) : Buffer(buffer) {}
     void mangleDeclName(NamedDecl *decl);
-    void mangleType(Type type);
+    void mangleType(Type type, ExplosionKind kind, unsigned uncurryingLevel);
 
   private:
     void mangleDeclContext(DeclContext *ctx);
@@ -151,7 +152,8 @@ void Mangler::mangleDeclContext(DeclContext *ctx) {
 
   case DeclContextKind::ExtensionDecl:
     // Mandle the extension as the original type.
-    mangleType(cast<ExtensionDecl>(ctx)->getExtendedType());
+    mangleType(cast<ExtensionDecl>(ctx)->getExtendedType(),
+               ExplosionKind::Minimal, 0);
     return;
 
   case DeclContextKind::FuncExpr:
@@ -174,7 +176,8 @@ void Mangler::mangleDeclName(NamedDecl *decl) {
 }
 
 /// Mangle a type into the buffer.
-void Mangler::mangleType(Type type) {
+void Mangler::mangleType(Type type, ExplosionKind explosion,
+                         unsigned uncurryLevel) {
   TypeBase *base = type.getPointer();
 
   switch (base->Kind) {
@@ -197,33 +200,32 @@ void Mangler::mangleType(Type type) {
     case BuiltinFloatType::IEEE64: Buffer << "f64"; return;
     case BuiltinFloatType::IEEE80: Buffer << "f80"; return;
     case BuiltinFloatType::IEEE128: Buffer << "f128"; return;
-    case BuiltinFloatType::PPC128: assert(0 && "Unimplemented");
+    case BuiltinFloatType::PPC128: llvm_unreachable("ppc128 not supported");
     }
-    assert(0 && "Unreachable");
+    llvm_unreachable("bad floating-point kind");
   case TypeKind::BuiltinInteger:
     Buffer << "i" << cast<BuiltinIntegerType>(type)->getBitWidth();
     return;
 
   case TypeKind::NameAlias:
-    return mangleType(cast<NameAliasType>(base)->TheDecl->getUnderlyingType());
+    return mangleType(cast<NameAliasType>(base)->TheDecl->getUnderlyingType(),
+                      explosion, uncurryLevel);
   case TypeKind::DottedName:
-    return mangleType(cast<DottedNameType>(base)->getMappedType());
+    return mangleType(cast<DottedNameType>(base)->getMappedType(),
+                      explosion, uncurryLevel);
   case TypeKind::Paren:
-    return mangleType(cast<ParenType>(base)->getUnderlyingType());
+    return mangleType(cast<ParenType>(base)->getUnderlyingType(),
+                      explosion, uncurryLevel);
 
   case TypeKind::Tuple: {
     TupleType *tuple = cast<TupleType>(base);
-    // Look through simple parentheses.
-    if (tuple->Fields.size() == 1 && tuple->Fields[0].Name.empty())
-      return mangleType(tuple->Fields[0].Ty);
-
     // type ::= 'T' tuple-field+ '_'
     // tuple-field ::= identifier? type
     Buffer << 'T';
     for (auto &field : tuple->Fields) {
       if (!field.Name.empty())
         mangleIdentifier(field.Name);
-      mangleType(field.Ty);
+      mangleType(field.Ty, explosion, 0);
     }
     Buffer << '_';
     return;
@@ -244,11 +246,13 @@ void Mangler::mangleType(Type type) {
   }
 
   case TypeKind::Function: {
-    // type ::= 'F' type type
+    // type ::= 'F' type type (curried)
+    // type ::= 'f' type type (uncurried)
     FunctionType *fn = cast<FunctionType>(base);
-    Buffer << 'F';
-    mangleType(fn->Input);
-    mangleType(fn->Result);
+    Buffer << (uncurryLevel > 0 ? 'f' : 'F');
+    mangleType(fn->Input, explosion, 0);
+    mangleType(fn->Result, explosion,
+               (uncurryLevel > 0 ? uncurryLevel - 1 : 0));
     return;
   }
 
@@ -257,7 +261,7 @@ void Mangler::mangleType(Type type) {
     ArrayType *array = cast<ArrayType>(base);
     Buffer << 'A';
     Buffer << array->Size;
-    mangleType(array->Base);
+    mangleType(array->Base, ExplosionKind::Minimal, 0);
     return;
   };
 
@@ -304,7 +308,7 @@ void LinkEntity::mangle(raw_ostream &buffer) const {
   // moment they can *all* be overloaded.
   if (ValueDecl *valueDecl = dyn_cast<ValueDecl>(TheDecl))
     if (!isa<TypeAliasDecl>(TheDecl))
-      mangler.mangleType(valueDecl->getType());
+      mangler.mangleType(valueDecl->getType(), Explosion, UncurryLevel);
 
   // TODO: mangle generics information here.
 }
