mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
e249fd680e
Similarly to how we've always handled parameter types, we now recursively expand tuples in result types and separately determine a result convention for each result. The most important code-generation change here is that indirect results are now returned separately from each other and from any direct results. It is generally far better, when receiving an indirect result, to receive it as an independent result; the caller is much more likely to be able to directly receive the result in the address they want to initialize, rather than having to receive it in temporary memory and then copy parts of it into the target. The most important conceptual change here that clients and producers of SIL must be aware of is the new distinction between a SILFunctionType's *parameters* and its *argument list*. The former is just the formal parameters, derived purely from the parameter types of the original function; indirect results are no longer in this list. The latter includes the indirect result arguments; as always, all the indirect results strictly precede the parameters. Apply instructions and entry block arguments follow the argument list, not the parameter list. A relatively minor change is that there can now be multiple direct results, each with its own result convention. This is a minor change because I've chosen to leave return instructions as taking a single operand and apply instructions as producing a single result; when the type describes multiple results, they are implicitly bound up in a tuple. It might make sense to split these up and allow e.g. return instructions to take a list of operands; however, it's not clear what to do on the caller side, and this would be a major change that can be separated out from this already over-large patch. Unsurprisingly, the most invasive changes here are in SILGen; this requires substantial reworking of both call emission and reabstraction. It also proved important to switch several SILGen operations over to work with RValue instead of ManagedValue, since otherwise they would be forced to spuriously "implode" buffers.
196 lines
8.3 KiB
C++
196 lines
8.3 KiB
C++
//===--- GenObjC.h - Swift IR generation for Objective-C --------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2016 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 provides the private interface to Objective-C emission code.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_IRGEN_GENOBJC_H
|
|
#define SWIFT_IRGEN_GENOBJC_H
|
|
|
|
|
|
namespace llvm {
|
|
class Type;
|
|
class Value;
|
|
}
|
|
|
|
namespace swift {
|
|
class CanType;
|
|
class FuncDecl;
|
|
struct SILDeclRef;
|
|
class SILType;
|
|
class Substitution;
|
|
|
|
namespace irgen {
|
|
class CallEmission;
|
|
class IRGenFunction;
|
|
class IRGenModule;
|
|
|
|
/// The kind of message to send through the Objective-C runtime.
|
|
enum class ObjCMessageKind {
|
|
/// A normally-dispatched call.
|
|
Normal,
|
|
/// A call to a superclass method.
|
|
Super,
|
|
/// A call to a peer method.
|
|
Peer
|
|
};
|
|
|
|
CallEmission prepareObjCMethodRootCall(IRGenFunction &IGF,
|
|
SILDeclRef method,
|
|
CanSILFunctionType origFnType,
|
|
CanSILFunctionType substFnType,
|
|
ArrayRef<Substitution> subs,
|
|
ObjCMessageKind kind);
|
|
|
|
void addObjCMethodCallImplicitArguments(IRGenFunction &IGF,
|
|
Explosion &emission,
|
|
SILDeclRef method,
|
|
llvm::Value *self,
|
|
SILType superSearchType);
|
|
|
|
/// Emit a partial application of an Objective-C method to its 'self'
|
|
/// argument.
|
|
void emitObjCPartialApplication(IRGenFunction &IGF,
|
|
SILDeclRef method,
|
|
CanSILFunctionType origType,
|
|
CanSILFunctionType partialAppliedType,
|
|
llvm::Value *self,
|
|
SILType selfType,
|
|
Explosion &out);
|
|
|
|
/// Reclaim an autoreleased return value.
|
|
llvm::Value *emitObjCRetainAutoreleasedReturnValue(IRGenFunction &IGF,
|
|
llvm::Value *value);
|
|
|
|
/// Autorelease a return value.
|
|
llvm::Value *emitObjCAutoreleaseReturnValue(IRGenFunction &IGF,
|
|
llvm::Value *value);
|
|
|
|
/// Build the components of an Objective-C method descriptor for the given
|
|
/// method or constructor implementation.
|
|
void emitObjCMethodDescriptorParts(IRGenModule &IGM,
|
|
AbstractFunctionDecl *method,
|
|
bool extendedEncoding,
|
|
bool concrete,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
/// Build the components of an Objective-C method descriptor for the given
|
|
/// property's method implementations.
|
|
void emitObjCGetterDescriptorParts(IRGenModule &IGM,
|
|
VarDecl *property,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
/// Build the components of an Objective-C method descriptor for the given
|
|
/// subscript's method implementations.
|
|
void emitObjCGetterDescriptorParts(IRGenModule &IGM,
|
|
SubscriptDecl *subscript,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
void emitObjCGetterDescriptorParts(IRGenModule &IGM,
|
|
AbstractStorageDecl *subscript,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
/// Build the components of an Objective-C method descriptor for the given
|
|
/// property's method implementations.
|
|
void emitObjCSetterDescriptorParts(IRGenModule &IGM,
|
|
VarDecl *property,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
/// Build the components of an Objective-C method descriptor for the given
|
|
/// subscript's method implementations.
|
|
void emitObjCSetterDescriptorParts(IRGenModule &IGM,
|
|
SubscriptDecl *subscript,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
void emitObjCSetterDescriptorParts(IRGenModule &IGM,
|
|
AbstractStorageDecl *subscript,
|
|
llvm::Constant *&selectorRef,
|
|
llvm::Constant *&atEncoding,
|
|
llvm::Constant *&impl);
|
|
|
|
/// Build an Objective-C method descriptor for the given method,
|
|
/// constructor, or destructor implementation.
|
|
llvm::Constant *emitObjCMethodDescriptor(IRGenModule &IGM,
|
|
AbstractFunctionDecl *method);
|
|
|
|
/// Build an Objective-C method descriptor for the ivar initializer
|
|
/// or destroyer of a class (-.cxx_construct or -.cxx_destruct).
|
|
///
|
|
/// \returns the method destructor, or an empty optional if there is
|
|
/// no corresponding SIL function.
|
|
Optional<llvm::Constant*> emitObjCIVarInitDestroyDescriptor(IRGenModule &IGM,
|
|
ClassDecl *cd,
|
|
bool isDestroyer);
|
|
|
|
/// Get the type encoding for an ObjC property.
|
|
void getObjCEncodingForPropertyType(IRGenModule &IGM, VarDecl *property,
|
|
std::string &s);
|
|
|
|
/// Produces extended encoding of ObjC block signature.
|
|
/// \returns the encoded type.
|
|
llvm::Constant *getBlockTypeExtendedEncoding(IRGenModule &IGM,
|
|
CanSILFunctionType invokeTy);
|
|
|
|
/// Produces extended encoding of method type.
|
|
/// \returns the encoded type.
|
|
llvm::Constant *getMethodTypeExtendedEncoding(IRGenModule &IGM,
|
|
AbstractFunctionDecl *method);
|
|
|
|
/// Build an Objective-C method descriptor for the given property's
|
|
/// getter and setter methods.
|
|
std::pair<llvm::Constant *, llvm::Constant *>
|
|
emitObjCPropertyMethodDescriptors(IRGenModule &IGM, VarDecl *property);
|
|
|
|
/// Build an Objective-C method descriptor for the given subscript's
|
|
/// getter and setter methods.
|
|
std::pair<llvm::Constant *, llvm::Constant *>
|
|
emitObjCSubscriptMethodDescriptors(IRGenModule &IGM,
|
|
SubscriptDecl *subscript);
|
|
|
|
/// True if the FuncDecl requires an ObjC method descriptor.
|
|
bool requiresObjCMethodDescriptor(FuncDecl *method);
|
|
|
|
/// True if the ConstructorDecl requires an ObjC method descriptor.
|
|
bool requiresObjCMethodDescriptor(ConstructorDecl *constructor);
|
|
|
|
/// True if the VarDecl requires ObjC accessor methods and a property
|
|
/// descriptor.
|
|
bool requiresObjCPropertyDescriptor(IRGenModule &IGM,
|
|
VarDecl *property);
|
|
|
|
/// True if the SubscriptDecl requires ObjC accessor methods.
|
|
bool requiresObjCSubscriptDescriptor(IRGenModule &IGM,
|
|
SubscriptDecl *subscript);
|
|
|
|
/// Allocate an Objective-C object.
|
|
llvm::Value *emitObjCAllocObjectCall(IRGenFunction &IGF,
|
|
llvm::Value *classPtr,
|
|
CanType resultType);
|
|
|
|
} // end namespace irgen
|
|
} // end namespace swift
|
|
|
|
#endif
|