| // Copyright 2019 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifndef SRC_DEVELOPER_DEBUG_ZXDB_EXPR_EVAL_DWARF_EXPR_H_ | |
| #define SRC_DEVELOPER_DEBUG_ZXDB_EXPR_EVAL_DWARF_EXPR_H_ | |
| #include <vector> | |
| #include "src/developer/debug/zxdb/expr/eval_callback.h" | |
| #include "src/developer/debug/zxdb/expr/expr_value.h" | |
| #include "src/developer/debug/zxdb/symbols/dwarf_expr_eval.h" | |
| #include "src/lib/fxl/memory/ref_counted.h" | |
| // This file bridges the C++/Rust expression system and the symbol system's DwarfExprEval which does | |
| // the low-level DWARF operation evaluation of DwarfExpr objects. In the simplest case you'll want | |
| // to evaluate a DWARF expression and get an ExprValue out. In that case, use: | |
| // | |
| // - DwarfExprToValue(...) | |
| // | |
| // There are some other uses that need more detailed control. Some code needs direct access to the | |
| // DwarfExprEval. These cases should use one of the helper objects: | |
| // | |
| // - If you want an ExprValue out but need to set up some initial state on the DwarfExprEval | |
| // before doing the evaluation, use AsyncDwarfExprEvalValue. | |
| // | |
| // - If you want raw access to the DwarfExprEval both before and after evaluation, use | |
| // AsyncDwarfExprEval. | |
| namespace zxdb { | |
| class EvalContext; | |
| class SymbolContext; | |
| class Type; | |
| // Evaluates the given DWARF expression and calls the callback with the result, using the given | |
| // type. See file comment above. | |
| void DwarfExprToValue(UnitSymbolFactory symbol_factory, | |
| const fxl::RefPtr<EvalContext>& eval_context, | |
| const SymbolContext& symbol_context, DwarfExpr expr, fxl::RefPtr<Type> type, | |
| EvalCallback cb); | |
| // Helper function which, given a completed DwarfExprEval, attempts to convert its result to the | |
| // given type and executes the given callback. | |
| void DwarfExprEvalToValue(const fxl::RefPtr<EvalContext>& context, DwarfExprEval& eval, | |
| fxl::RefPtr<Type> type, EvalCallback cb); | |
| // Manages evaluation of a DWARF expression (which might be asynchronous and need some tricky memory | |
| // management). This keeps itself and the expression evaluator alive during the computation. | |
| // | |
| // See the file comment above, most callers will want one of the other variants. | |
| // | |
| // Example: | |
| // | |
| // auto eval = fxl::MakeRefCounted<AsyncDwarfExprEval>([](DwarfExprEval& eval) { | |
| // eval->...(); | |
| // }); | |
| // eval->Eval(data_provider, expression); | |
| // | |
| class AsyncDwarfExprEval : public fxl::RefCountedThreadSafe<AsyncDwarfExprEval> { | |
| public: | |
| using DwarfEvalCallback = fit::callback<void(DwarfExprEval&, const Err& err)>; | |
| // Allows the expression evaluator to be set up before Eval() is called for cases where it needs | |
| // initial state. | |
| DwarfExprEval& dwarf_eval() { return dwarf_eval_; } | |
| // Starts evaluation. It will take a reference to itself during execution and the callback passed | |
| // into the constructor will be issued on completion. This can only be called once. | |
| // | |
| // The symbol context should be the one for the module the expression came from so that addresses | |
| // within the expression can be interpreted correctly. | |
| void Eval(DwarfExpr expr); | |
| protected: | |
| FRIEND_REF_COUNTED_THREAD_SAFE(AsyncDwarfExprEval); | |
| FRIEND_MAKE_REF_COUNTED(AsyncDwarfExprEval); | |
| explicit AsyncDwarfExprEval(UnitSymbolFactory symbol_factory, | |
| fxl::RefPtr<SymbolDataProvider> data_provider, | |
| const SymbolContext& expr_symbol_context, DwarfEvalCallback cb) | |
| : dwarf_eval_(std::move(symbol_factory), std::move(data_provider), expr_symbol_context), | |
| dwarf_callback_(std::move(cb)) {} | |
| virtual ~AsyncDwarfExprEval() = default; | |
| private: | |
| DwarfExprEval dwarf_eval_; | |
| DwarfEvalCallback dwarf_callback_; | |
| }; | |
| // Automatically converts the result of the DwarfExprEval to an EvalCallback (an error or a value). | |
| // See the simpler DwarfExprToValue() function above for cases that don't need low-level access to | |
| // the DwarfExprEval object. | |
| // | |
| // Example: | |
| // | |
| // auto eval = fxl::MakeRefCounted<AsyncDwarfExprEvalValue>(context, type, std::move(cb)); | |
| // ...any required setup of the dwarf_eval()... | |
| // eval->Eval(context->GetDataProvider(), expression); | |
| // | |
| class AsyncDwarfExprEvalValue : public AsyncDwarfExprEval { | |
| public: | |
| // Call Eval() on the base class to start evaluation. | |
| protected: | |
| FRIEND_REF_COUNTED_THREAD_SAFE(AsyncDwarfExprEvalValue); | |
| FRIEND_MAKE_REF_COUNTED(AsyncDwarfExprEvalValue); | |
| // The passed-in callback will be executed if the DwarfExprEval returns success. It will have | |
| // the given type. | |
| AsyncDwarfExprEvalValue(UnitSymbolFactory symbol_factory, | |
| fxl::RefPtr<SymbolDataProvider> data_provider, | |
| const SymbolContext& expr_symbol_context, | |
| const fxl::RefPtr<EvalContext>& context, fxl::RefPtr<Type> type, | |
| EvalCallback cb); | |
| private: | |
| void OnEvalComplete(const Err& err); | |
| fxl::RefPtr<EvalContext> context_; | |
| // Not necessarily a concrete type, this is the type of the result the user will see. | |
| fxl::RefPtr<Type> type_; | |
| EvalCallback value_callback_; | |
| }; | |
| } // namespace zxdb | |
| #endif // SRC_DEVELOPER_DEBUG_ZXDB_EXPR_EVAL_DWARF_EXPR_H_ |