bf-p4c-options.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_BF_P4C_OPTIONS_H_
#define BACKENDS_TOFINO_BF_P4C_BF_P4C_OPTIONS_H_
 
#include "frontends/common/applyOptionsPragmas.h"
#include "frontends/common/options.h"
#include "lib/cstring.h"
#include "logging/bf_error_reporter.h"
 
class BFN_Options : public CompilerOptions {
 public:
    bool allowUnimplemented = false;
    bool debugInfo = false;
    bool no_deadcode_elimination = false;
    bool forced_placement = false;
    bool use_clot = true;
    bool no_tagalong = false;
    float phv_scale_factor = 1;
    float max_power = 0.0;
    bool create_graphs = false;
    bool decaf = false;
    bool auto_init_metadata = false;
    bool disable_parser_state_merging = false;
    bool backward_compatible = false;
    bool display_power_budget = false;
    bool disable_power_check = false;
    bool disable_mpr_config = false;
    bool force_match_dependency = false;
    bool infer_payload_offset = false;
    bool parser_timing_reports = false;
    bool parser_bandwidth_opt = false;
    bool egress_intr_md_opt = false;
    bool disable_direct_exit = false;
    bool disable_long_branch = false;
    bool disable_dark_allocation = false;
    bool disable_split_attached = false;
    bool disable_table_placement_backfill = false;
    bool disable_egress_latency_padding = false;
    bool table_placement_in_order = false;
    bool table_placement_long_branch_backtrack = false;
    bool disable_gfm_parity = true;
    int relax_phv_init = 0;
    bool quick_phv_alloc = false;
#ifdef ALT_PHV_ALLOC_DEFAULT
    bool alt_phv_alloc = ALT_PHV_ALLOC_DEFAULT;
#else
    bool alt_phv_alloc = false;
#endif
    int traffic_limit = 100;
    int num_stages_override = 0;
    bool enable_event_logger = false;
    bool disable_parse_min_depth_limit = false;
    bool disable_parse_max_depth_limit = false;
    bool alt_phv_alloc_meta_init = false;
#if BAREFOOT_INTERNAL || 1
    // FIXME -- Cmake does not consistently set BAREFOOT_INTERNAL for all source
    // files (why?), so having the layout of any class depend on it will result in
    // different object files disagreeing on the layout, leading to random memory
    // corruption.  So we always include these fields; they're just unused in release
    // The particular problem seems to be with gtest -- gtest source files are built
    // with BAREFOOT_INTERNAL unset, whil backend files are built with it set.
    std::set<cstring> skipped_pipes;
    bool no_power_check = false;
    bool stage_allocation = false;
    bool tof2lab44_workaround = false;
    bool skip_seo = true;  // still skipping by default currently
#endif
    bool verbose = false;
 
    // FIXME: Temporarily allow manual aliasing of POV bits to address POV bit
    // growth caused by varbit headers. Only a single bit is needed on Tofino 2 if the varbit is
    // allocated to a CLOT.
    bool allow_pov_aliasing = false;
 
    cstring bfRtSchema = ""_cs;
    bool p4RuntimeForceStdExterns = false;
    cstring programName;
    cstring outputDir = nullptr;  // output directory, default "programName.device"
 
    // Default value on v1ModelVersion must be set based on changes to p4c
    // frontend. Check PR 2706 in p4lang/p4c. This value will need an update
    // whenever latest version model number changes in the frontend
    int v1ModelVersion = 20200408;
 
    BFN_Options();

    std::vector<const char *> *process(int argc, char *const argv[]) override;
 
    // private:
    // BFN_Options::process is called twice: once from the main, and once
    // from applyPragmaOptions to handle pragma command_line.
    // This variable prevents doing the actions below twice, since the
    // pragma command line will only invoke the callbacks for the
    // respective options.
    bool processed = false;
    // FIXME: Must be eventually moved to a program specific data structure
    // which is accessible by Backend as this is currently not set through
    // command line option but a convenient place to store global program
    // information
    // Set pipe ids for program, for a multipipe program all valid pipe ids will be set
    unsigned pipes = 0;
    // Set ghost pipe ids for program, for a multipipe program all pipes with
    // ghost threads will be set
    unsigned ghost_pipes = 0;
    unsigned int inclusive_max_errors_before_enforcing_silence_other_than_the_summary = INT_MAX;
};
class BFN_Options : public CompilerOptions {…};
 
// forward declarations so we do not include ir-generated.h
namespace P4 {
namespace IR {
class P4Program;      // NOLINT(build/forward_decl)
class ToplevelBlock;  // NOLINT(build/forward_decl)
}  // namespace IR
}  // namespace P4

class BFNContext : public virtual P4CContext {
 public:
    static BFNContext &get();

    BFN_Options &options() override;

    void setBackendOptions(BFN_Options *options);

    void clearBackendOptions();

    cstring getOutputDirectory(const cstring &suffix = cstring(), int pipe_id = -1);

    void discoverPipes(const IR::P4Program *, const IR::ToplevelBlock *);

    cstring &getPipeName(int pipe_id) {
        static cstring empty("");
        if (_pipes.count(pipe_id)) return _pipes.at(pipe_id);
        return empty;
    }
    cstring &getPipeName(int pipe_id) {…}

    bool isPipeName(const cstring &name) {
        for (auto pipe : _pipes) {
            if (pipe.second == name) return true;
        }
        return false;
    }
 
    BfErrorReporter &errorReporter() override;
 
 private:
    bool isRecognizedDiagnostic(cstring diagnostic) final;

    BFN_Options primaryOptions;

    thread_local static BFN_Options *optionsInstance;

    std::map<int, cstring> _pipes;
 
    BfErrorReporter bfErrorReporter;
};
class BFNContext : public virtual P4CContext {…};
 
inline BFN_Options &BackendOptions() { return BFNContext::get().options(); }

class BFNOptionPragmaParser : public P4::P4COptionPragmaParser {
 public:
    std::optional<CommandLineOptions> tryToParse(const IR::Annotation *annotation) override;
 
    BFNOptionPragmaParser() : P4::P4COptionPragmaParser(false) {}
    // FIXME -- should remove the tofino @command_line stuff and use the base class
 
 private:
    std::optional<CommandLineOptions> parseCompilerOption(const IR::Annotation *annotation);
};
class BFNOptionPragmaParser : public P4::P4COptionPragmaParser {…};
 
#endif /* BACKENDS_TOFINO_BF_P4C_BF_P4C_OPTIONS_H_ */