mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1d961ba22d
Although I don't plan to bring over new assertions wholesale into the current qualification branch, it's entirely possible that various minor changes in main will use the new assertions; having this basic support in the release branch will simplify that. (This is why I'm adding the includes as a separate pass from rewriting the individual assertions)
88 lines
3.2 KiB
C++
88 lines
3.2 KiB
C++
//===-------- SILDebugInfoExpression.cpp - DIExpression for SIL -----------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file contains the table used by SILDIExprInfo to map from
|
|
/// SILDIExprOperator to supplement information like the operator string.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Basic/Assertions.h"
|
|
#include "swift/SIL/SILDebugInfoExpression.h"
|
|
#include <unordered_map>
|
|
|
|
using namespace swift;
|
|
|
|
namespace std {
|
|
// This is, unfortunately, a workaround for an ancient bug in libstdc++:
|
|
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970
|
|
// Which prevented std::hash<T> users from having drop-in support for
|
|
// enum class types.
|
|
template <> struct hash<SILDIExprOperator> {
|
|
size_t operator()(SILDIExprOperator V) const noexcept {
|
|
return std::hash<unsigned>{}(static_cast<unsigned>(V));
|
|
}
|
|
};
|
|
} // end namespace std
|
|
|
|
const SILDIExprInfo *SILDIExprInfo::get(SILDIExprOperator Op) {
|
|
static const std::unordered_map<SILDIExprOperator, SILDIExprInfo> Infos = {
|
|
{SILDIExprOperator::Fragment,
|
|
{"op_fragment", {SILDIExprElement::DeclKind}}},
|
|
{SILDIExprOperator::TupleFragment,
|
|
{"op_tuple_fragment",
|
|
{SILDIExprElement::TypeKind, SILDIExprElement::ConstIntKind}}},
|
|
{SILDIExprOperator::Dereference, {"op_deref", {}}},
|
|
{SILDIExprOperator::Plus, {"op_plus", {}}},
|
|
{SILDIExprOperator::Minus, {"op_minus", {}}},
|
|
{SILDIExprOperator::ConstUInt,
|
|
{"op_constu", {SILDIExprElement::ConstIntKind}}},
|
|
{SILDIExprOperator::ConstSInt,
|
|
{"op_consts", {SILDIExprElement::ConstIntKind}}}};
|
|
|
|
return Infos.count(Op) ? &Infos.at(Op) : nullptr;
|
|
}
|
|
|
|
void SILDebugInfoExpression::op_iterator::increment() {
|
|
if (Remain.empty()) {
|
|
// Effectively making this an end iterator
|
|
Current = {};
|
|
return;
|
|
}
|
|
|
|
const SILDIExprElement &NextHead = Remain[0];
|
|
SILDIExprOperator Op = NextHead.getAsOperator();
|
|
if (const auto *ExprInfo = SILDIExprInfo::get(Op)) {
|
|
auto NewSlice = Remain.take_front(ExprInfo->OperandKinds.size() + 1);
|
|
Current = SILDIExprOperand(NewSlice.data(), NewSlice.size());
|
|
if (Remain.size() >= Current.size())
|
|
Remain = Remain.drop_front(Current.size());
|
|
}
|
|
}
|
|
|
|
SILDebugInfoExpression SILDebugInfoExpression::createFragment(VarDecl *Field) {
|
|
assert(Field);
|
|
return SILDebugInfoExpression(
|
|
{SILDIExprElement::createOperator(SILDIExprOperator::Fragment),
|
|
SILDIExprElement::createDecl(Field)});
|
|
}
|
|
|
|
SILDebugInfoExpression
|
|
SILDebugInfoExpression::createTupleFragment(TupleType *TypePtr, unsigned Idx) {
|
|
assert(TypePtr);
|
|
return SILDebugInfoExpression(
|
|
{SILDIExprElement::createOperator(SILDIExprOperator::TupleFragment),
|
|
SILDIExprElement::createType(TypePtr),
|
|
SILDIExprElement::createConstInt(Idx)});
|
|
}
|
|
|