mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
11f0ff6e32
For years, optimizer engineers have been hitting a common bug caused by passes assuming all SILValues have a parent function only to be surprised by SILUndef. Generally we see SILUndef not that often so we see this come up later in testing. This patch eliminates that problem by making SILUndef uniqued at the function level instead of the module level. This ensures that it makes sense for SILUndef to have a parent function, eliminating this possibility since we can define an API to get its parent function. rdar://123484595
311 lines
11 KiB
C++
311 lines
11 KiB
C++
//===--- DeserializeSIL.h - Read SIL ----------------------------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ModuleFile.h"
|
|
#include "SILFormat.h"
|
|
#include "swift/AST/Types.h"
|
|
#include "swift/SIL/SILModule.h"
|
|
#include "swift/SIL/SILMoveOnlyDeinit.h"
|
|
#include "swift/Serialization/SerializedSILLoader.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/Support/SaveAndRestore.h"
|
|
|
|
namespace llvm {
|
|
template <typename Info> class OnDiskIterableChainedHashTable;
|
|
}
|
|
|
|
namespace swift {
|
|
class SILDeserializer {
|
|
using TypeID = serialization::TypeID;
|
|
|
|
ModuleFile *MF;
|
|
SILModule &SILMod;
|
|
DeserializationNotificationHandlerSet *Callback;
|
|
|
|
/// The cursor used to lazily load SILFunctions.
|
|
llvm::BitstreamCursor SILCursor;
|
|
llvm::BitstreamCursor SILIndexCursor;
|
|
|
|
class FuncTableInfo;
|
|
using SerializedFuncTable =
|
|
llvm::OnDiskIterableChainedHashTable<FuncTableInfo>;
|
|
|
|
//-----
|
|
// Deserialization Caches
|
|
//
|
|
// NOTE: When adding more serialized tables to the deserializer,
|
|
// always add invalidate methods and make sure SILModule always
|
|
// invalidates the deserializer appropriately when it erases a
|
|
// value that we deserialized here. Otherwise, memory corruption
|
|
// may result.
|
|
|
|
std::unique_ptr<SerializedFuncTable> FuncTable;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILFunction*>> Funcs;
|
|
|
|
std::unique_ptr<SerializedFuncTable> GlobalVarList;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILGlobalVariable *>>
|
|
GlobalVars;
|
|
|
|
std::unique_ptr<SerializedFuncTable> VTableList;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILVTable *>> VTables;
|
|
|
|
std::unique_ptr<SerializedFuncTable> MoveOnlyDeinitList;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILMoveOnlyDeinit *>>
|
|
MoveOnlyDeinits;
|
|
|
|
std::unique_ptr<SerializedFuncTable> WitnessTableList;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILWitnessTable *>>
|
|
WitnessTables;
|
|
|
|
std::unique_ptr<SerializedFuncTable> DefaultWitnessTableList;
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILDefaultWitnessTable *>>
|
|
DefaultWitnessTables;
|
|
|
|
MutableArrayRef<ModuleFile::PartiallySerialized<SILProperty *>>
|
|
Properties;
|
|
|
|
std::unique_ptr<SerializedFuncTable> DifferentiabilityWitnessList;
|
|
MutableArrayRef<
|
|
ModuleFile::PartiallySerialized<SILDifferentiabilityWitness *>>
|
|
DifferentiabilityWitnesses;
|
|
|
|
//-----
|
|
// End Deserialization Caches
|
|
//
|
|
// Before adding a new cache here, please read the comment at the
|
|
// beginning of the deserialization cache section.
|
|
|
|
/// A declaration will only
|
|
llvm::DenseMap<NormalProtocolConformance *, SILWitnessTable *>
|
|
ConformanceToWitnessTableMap;
|
|
|
|
/// Data structures used to perform name lookup for local values.
|
|
llvm::DenseMap<uint32_t, ValueBase*> LocalValues;
|
|
|
|
/// The first two local values are reserved for SILUndef.
|
|
serialization::ValueID LastValueID = 1;
|
|
|
|
/// Data structures used to perform lookup of basic blocks.
|
|
llvm::DenseMap<unsigned, SILBasicBlock*> BlocksByID;
|
|
llvm::DenseMap<SILBasicBlock*, unsigned> UndefinedBlocks;
|
|
unsigned BasicBlockID = 0;
|
|
|
|
/// Return the SILBasicBlock of a given ID.
|
|
SILBasicBlock *getBBForReference(SILFunction *Fn, unsigned ID);
|
|
SILBasicBlock *getBBForDefinition(SILFunction *Fn, SILBasicBlock *Prev,
|
|
unsigned ID);
|
|
|
|
/// Read a SIL function.
|
|
SILFunction *readSILFunction(serialization::DeclID, SILFunction *InFunc,
|
|
StringRef Name, bool declarationOnly,
|
|
bool errorIfEmptyBody = true);
|
|
/// Read a SIL function.
|
|
llvm::Expected<SILFunction *>
|
|
readSILFunctionChecked(serialization::DeclID, SILFunction *InFunc,
|
|
StringRef Name, bool declarationOnly,
|
|
bool errorIfEmptyBody = true);
|
|
|
|
/// Read a SIL basic block within a given SIL function.
|
|
SILBasicBlock *readSILBasicBlock(SILFunction *Fn,
|
|
SILBasicBlock *Prev,
|
|
SmallVectorImpl<uint64_t> &scratch);
|
|
/// Read a SIL instruction.
|
|
bool readSILInstruction(SILFunction *Fn,
|
|
SILBuilder &Builder,
|
|
unsigned RecordKind,
|
|
SmallVectorImpl<uint64_t> &scratch);
|
|
|
|
/// Read the SIL function table.
|
|
std::unique_ptr<SerializedFuncTable>
|
|
readFuncTable(ArrayRef<uint64_t> fields, StringRef blobData);
|
|
|
|
/// When an instruction or block argument is defined, this method is used to
|
|
/// register it and update our symbol table.
|
|
void setLocalValue(ValueBase *Value, serialization::ValueID Id);
|
|
|
|
/// Get a reference to a local value with the specified ID and type.
|
|
///
|
|
/// NOTE: \p inContext is expected to be nullptr if we are inserting into a
|
|
/// global variable initializer.
|
|
SILValue getLocalValue(SILFunction *inContext, serialization::ValueID Id,
|
|
SILType Type);
|
|
|
|
SILType getSILType(Type ty, SILValueCategory category,
|
|
SILFunction *inContext);
|
|
|
|
SILDifferentiabilityWitness *
|
|
getSILDifferentiabilityWitnessForReference(StringRef mangledKey);
|
|
|
|
SILFunction *getFuncForReference(StringRef Name, SILType Ty, TypeExpansionContext context);
|
|
SILFunction *getFuncForReference(StringRef Name);
|
|
SILVTable *readVTable(serialization::DeclID);
|
|
SILMoveOnlyDeinit *readMoveOnlyDeinit(serialization::DeclID);
|
|
SILGlobalVariable *getGlobalForReference(StringRef Name);
|
|
SILGlobalVariable *readGlobalVar(StringRef Name);
|
|
|
|
/// Read and return the witness table identified with \p WId.
|
|
SILWitnessTable *readWitnessTable(serialization::DeclID WId,
|
|
SILWitnessTable *existingWt);
|
|
|
|
/// Read the witness table identified with \p WId, return the table or
|
|
/// the first error if any.
|
|
llvm::Expected<SILWitnessTable *>
|
|
readWitnessTableChecked(serialization::DeclID WId,
|
|
SILWitnessTable *existingWt);
|
|
|
|
void readWitnessTableEntries(
|
|
llvm::BitstreamEntry &entry,
|
|
std::vector<SILWitnessTable::Entry> &witnessEntries,
|
|
std::vector<SILWitnessTable::ConditionalConformance>
|
|
&conditionalConformances);
|
|
SILProperty *readProperty(serialization::DeclID);
|
|
SILDefaultWitnessTable *
|
|
readDefaultWitnessTable(serialization::DeclID,
|
|
SILDefaultWitnessTable *existingWt);
|
|
SILDifferentiabilityWitness *
|
|
readDifferentiabilityWitness(serialization::DeclID);
|
|
|
|
std::optional<KeyPathPatternComponent>
|
|
readKeyPathComponent(ArrayRef<uint64_t> ListOfValues, unsigned &nextValue);
|
|
|
|
public:
|
|
Identifier getModuleIdentifier() const {
|
|
return MF->getAssociatedModule()->getName();
|
|
}
|
|
FileUnit *getFile() const {
|
|
return MF->getFile();
|
|
}
|
|
SILFunction *lookupSILFunction(SILFunction *InFunc, bool onlyUpdateLinkage);
|
|
SILFunction *lookupSILFunction(StringRef Name,
|
|
bool declarationOnly = false);
|
|
bool hasSILFunction(StringRef Name,
|
|
std::optional<SILLinkage> Linkage = std::nullopt);
|
|
SILVTable *lookupVTable(StringRef MangledClassName);
|
|
SILMoveOnlyDeinit *lookupMoveOnlyDeinit(StringRef mangledNominalTypeName);
|
|
SILWitnessTable *lookupWitnessTable(SILWitnessTable *wt);
|
|
SILDefaultWitnessTable *
|
|
lookupDefaultWitnessTable(SILDefaultWitnessTable *wt);
|
|
SILDifferentiabilityWitness *
|
|
lookupDifferentiabilityWitness(StringRef mangledDiffWitnessKey);
|
|
|
|
/// Invalidate all cached SILFunctions.
|
|
void invalidateFunctionCache();
|
|
|
|
/// Invalidate a specific cached SILFunction.
|
|
bool invalidateFunction(SILFunction *F);
|
|
|
|
/// Invalidate all cached SILGlobalVariable.
|
|
void invalidateGlobalVariableCache();
|
|
|
|
/// Invalidate a specific cached GlobalVariable.
|
|
bool invalidateGlobalVariable(SILGlobalVariable *gv);
|
|
|
|
/// Invalidate all cached SILVTable.
|
|
void invalidateVTableCache();
|
|
|
|
/// Invalidate a specific cached SILVTable.
|
|
bool invalidateVTable(SILVTable *v);
|
|
|
|
/// Invalidate all cached SILWitnessTable.
|
|
void invalidateWitnessTableCache();
|
|
|
|
/// Invalidate a specific cached SILWitnessTable.
|
|
bool invalidateWitnessTable(SILWitnessTable *v);
|
|
|
|
/// Invalidate all cached SILDefaultWitnessTable.
|
|
void invalidateDefaultWitnessTableCache();
|
|
|
|
/// Invalidate a specific cached SILDefaultWitnessTable.
|
|
bool invalidateDefaultWitnessTable(SILDefaultWitnessTable *v);
|
|
|
|
/// Invalidate all cached SILProperty.
|
|
void invalidatePropertyCache();
|
|
|
|
/// Invalidate a specific cached SILProperty.
|
|
bool invalidateProperty(SILProperty *v);
|
|
|
|
/// Invalidate all cached SILDifferentiabilityWitness.
|
|
void invalidateDifferentiabilityWitnessCache();
|
|
|
|
/// Invalidate a specific cached SILDifferentiabilityWitness.
|
|
bool invalidateDifferentiabilityWitness(SILDifferentiabilityWitness *v);
|
|
|
|
/// Invalidate all caches in this deserializer.
|
|
void invalidateAllCaches() {
|
|
invalidateFunctionCache();
|
|
invalidateGlobalVariableCache();
|
|
invalidateVTableCache();
|
|
invalidateWitnessTableCache();
|
|
invalidateDefaultWitnessTableCache();
|
|
invalidatePropertyCache();
|
|
invalidateDifferentiabilityWitnessCache();
|
|
}
|
|
|
|
/// Deserialize all SILFunctions, VTables, WitnessTables, and
|
|
/// DefaultWitnessTables inside the module, and add them to SILMod.
|
|
///
|
|
/// TODO: Globals.
|
|
void getAll(bool UseCallback = true) {
|
|
llvm::SaveAndRestore<DeserializationNotificationHandlerSet *> SaveCB(
|
|
Callback);
|
|
|
|
if (!UseCallback)
|
|
Callback = nullptr;
|
|
|
|
getAllSILFunctions();
|
|
getAllSILGlobalVariables();
|
|
getAllVTables();
|
|
getAllWitnessTables();
|
|
getAllDefaultWitnessTables();
|
|
getAllProperties();
|
|
getAllDifferentiabilityWitnesses();
|
|
getAllMoveOnlyDeinits();
|
|
}
|
|
|
|
/// Deserialize all SILFunctions inside the module and add them to SILMod.
|
|
void getAllSILFunctions();
|
|
|
|
/// Deserialize all SILGlobalVariables inside the module and add them to
|
|
/// SILMod.
|
|
void getAllSILGlobalVariables();
|
|
|
|
/// Deserialize all VTables inside the module and add them to SILMod.
|
|
void getAllVTables();
|
|
|
|
/// Deserialize all move only deinit tables inside the module and add them
|
|
/// to SILMod.
|
|
void getAllMoveOnlyDeinits();
|
|
|
|
/// Deserialize all WitnessTables inside the module and add them to SILMod.
|
|
void getAllWitnessTables();
|
|
|
|
/// Deserialize all DefaultWitnessTables inside the module and add them
|
|
/// to SILMod.
|
|
void getAllDefaultWitnessTables();
|
|
|
|
/// Deserialize all Property descriptors inside the module and add them
|
|
/// to SILMod.
|
|
void getAllProperties();
|
|
|
|
/// Deserialize all DifferentiabilityWitnesses inside the module and add
|
|
/// them to SILMod.
|
|
void getAllDifferentiabilityWitnesses();
|
|
|
|
SILDeserializer(ModuleFile *MF, SILModule &M,
|
|
DeserializationNotificationHandlerSet *callback);
|
|
|
|
// Out of line to avoid instantiation OnDiskChainedHashTable here.
|
|
~SILDeserializer();
|
|
};
|
|
} // end namespace swift
|