P4 Namespace Reference

Namespaces
namespace	ControlPlaneAPI
	TODO(antonin): High level goals of the generator go here!!
namespace	Coverage
namespace	literals

Classes
class	AbstractInliner
class	AbstractParserDriver
class	ActionCall
class	ActionInvocation
class	ActionReplacement
class	ActionsInliner
class	ActionSynthesisPolicy
class	AddMissingIdAnnotations
class	AllDefinitions
class	AnalyzeParser
class	AnnotationSelectionPolicy
class	AnyElement
class	ApplyMethod
class	ApplyOptionsPragmas
class	ApplyTypesToExpressions
class	ArrayLocation
class	BaseLocation
class	BinaryConstraint
	Base class for EqualityConstraint and CanBeImplicitlyCastConstraint. More...
class	BindTypeVariables
class	BuiltInMethod
class	CallGraph
struct	CallInfo
	Describes information about a caller-callee pair. More...
class	CanBeImplicitlyCastConstraint
	The right type can be implicitly cast to the left type. More...
class	CastBooleanTableKeys
class	CheckConstants
class	CheckCoreMethods
class	CheckDeprecated
class	CheckExternInvocationCommon
	Base class which can be used to prepare classes for checking constraints for invocations of externs (both methods and pure functions) in parsers and control blocks. More...
class	CheckNamedArgs
class	CheckTableSize
	Checks some possible misuses of the table size property. More...
class	ChooseEnumRepresentation
class	ChooseErrorRepresentation
class	ClearTypeMap
class	CloneConstants
class	ClonePathExpressions
class	CloneVariableDeclarations
class	CompileTimeOperations
class	ComplexValues
class	ComputeDefUse
	Compute defuse info within P4Parser and P4Control blocks in the midend. More...
class	ComputeParserCG
	Builds a CallGraph of ParserState nodes. More...
class	ComputeWriteSet
class	ConstantFolding
class	ConstantFoldingPolicy
class	ConstructorCall
struct	ConstructorMap
class	ContainerConstructorCall
class	ContainsType
class	ControlInstantiation
class	ConvertEnums
class	ConvertErrors
class	CopySrcInfo
class	CopyStructures
class	CreateBuiltins
class	CreateSpecializedTypes
class	CreateStructInitializers
	Converts some list expressions into struct initializers. More...
class	DeclarationLookup
class	DefaultArguments
class	DefaultValues
class	Definitions
	List of definers for each base storage (at a specific program point). More...
class	Deprecated
class	DiscoverActionsInlining
class	DiscoverFunctionsInlining
class	DiscoverInlining
	Must be run after an evaluator; uses the blocks to discover caller/callee relationships. More...
class	DoBindTypeVariables
class	DoCheckConstants
class	DoCheckCoreMethods
	Check types for arguments of core.p4 methods. More...
class	DoConstantFolding
	statically evaluates many constant expressions. More...
class	DoConvertEnums
class	DoConvertErrors
class	DoCopyStructures
class	DoDefaultArguments
class	DoDefaultValues
class	DoEliminateInvalidHeaders
class	DoEliminateSerEnums
class	DoEliminateSwitch
class	DoEntryPriorities
	Assigns priorities to table entries if they are not 'const'. More...
class	DoExpandEmit
class	DoExpandLookahead
class	DoFlattenHeaderUnion
class	DoFlattenHeaderUnionStack
class	DoGlobalCopyPropagation
class	DoHandleNoMatch
class	DoInstantiateCalls
class	DoLocalCopyPropagation
class	DoMoveActionsToTables
class	DontcareArgs
class	DoOrderArguments
class	DoRemoveActionParameters
class	DoRemoveAssertAssume
class	DoRemoveExits
class	DoRemoveLeftSlices
class	DoRemoveMiss
class	DoRemoveParserControlFlow
	Converts if statements in parsers into transitions. More...
class	DoRemoveReturns
class	DoRemoveSelectBooleans
class	DoReplaceNewtype
class	DoReplaceSelectRange
class	DoReplaceTuples
class	DoReplaceTypedef
class	DoResetHeaders
	Explicitly invalidate uninitialized header variables. More...
class	DoSetHeaders
class	DoSimplifyControlFlow
	Replace complex control flow nodes with simpler ones where possible. More...
class	DoSimplifyDefUse
class	DoSimplifyExpressions
	Convert expressions so that each expression contains at most one side effect. More...
class	DoSimplifyKey
class	DoSimplifyParsers
	Remove unreachable parser states, and collapse simple chains of states. More...
class	DoSimplifySelectCases
class	DoSimplifySwitch
	Simplify select and switch statements that have constant arguments. More...
class	DoSingleArgumentSelect
class	DoStaticAssert
class	DoStrengthReduction
class	DoSynthesizeActions
class	DoTableHit
class	DoTableKeyNames
class	DuplicateActions
class	EliminateInvalidHeaders
class	EliminateNewtype
class	EliminateSerEnums
class	EliminateSubparserCalls
class	EliminateSwitch
class	EliminateTuples
class	EliminateTypedef
class	EntryPriorities
class	EnumInstance
class	EnumOn32Bits
class	EnumRepresentation
class	EqualityConstraint
	Requires two types to be equal. More...
class	Evaluator
class	EvaluatorPass
class	ExpandEmit
class	ExpandLookahead
class	Explain
	Creates a string that describes the values of current type variables. More...
class	ExpressionEvaluator
class	ExternConstructorCall
class	ExternFunction
struct	ExternInstance
class	ExternInstantiation
class	ExternMethod
class	FillEnumMap
class	FindActionParameters
class	FindFunctionSpecializations
class	FindGlobalActionUses
class	FindHeaderTypesToReplace
class	FindParameters
	Finds parameters for actions that will be given unique names. More...
class	FindRedundantParsers
class	FindRepeatedActionUses
class	FindSpecializations
class	FindSymbols
class	FindTypesInLogMsgInvocationToReplace
class	FindTypeSpecializations
class	FindTypesToReplace
class	FindVariableValues
class	FlattenHeaders
class	FlattenHeaderUnion
class	FlattenInterfaceStructs
class	FlattenLogMsg
class	FrontEnd
class	FrontEndPolicy
class	FunctionCall
class	FunctionsInliner
struct	FunctionSpecialization
	Describes how a generic function is specialized. More...
struct	FunctionSpecializationMap
class	GeneralInliner
	Performs actual inlining work. More...
class	GlobalActionReplacements
class	GlobalCopyPropagation
class	HandleNoMatch
class	HandleValidityHeaderUnion
class	HasExits
class	HasTableApply
	Checks to see whether an IR node includes a table.apply() sub-expression. More...
class	HierarchicalNames
class	HSIndexContretizer
class	HSIndexFinder
class	HSIndexSimplifier
class	HSIndexTransform
	This class substitutes index of a header stack in all occurences of found header stack. More...
class	IfInParser
	Detect whether the program contains an 'if' statement in a parser. More...
class	IHasBlock
class	IndexedLocation
	Interface for locations that support an index operation. More...
class	Inline
class	InlineActions
class	InlineDriver
class	InlineFunctions
class	InlineList
class	InlinePass
	Performs one round of inlining bottoms-up. More...
struct	InlineSummary
	Summarizes all inline operations to be performed. More...
class	InstanceBase
class	InstantiateDirectCalls
class	Instantiation
	Used to resolve a Declaration_Instance. More...
class	IOptionPragmaParser
class	IsLikeLeftValue
class	IsMask
class	IsNonConstantArrayIndex
class	IsValid
class	KeyIsSimple
class	KeyNameGenerator
class	KeySideEffect
class	LocalCopyPropagation
class	LocalizeActions
class	LocalizeAllActions
struct	LocationPath
class	LocationSet
class	MethodInstance
class	MidEndLast
class	MinimalNameGenerator
class	MissingIdAssigner
class	MoveActionsToTables
class	MoveConstructors
class	MoveDeclarations
class	MoveInitializers
class	NameGenerator
struct	NestedStructMap
class	NestedStructs
class	OrderArguments
class	OrPolicy
class	P4COptionPragmaParser
class	P4CoreLibrary
class	P4Exception_Model
class	P4ParserDriver
	A ParserDriver that can parse P4-16 programs. More...
struct	P4RuntimeAPI
class	P4RuntimeSerializer
	Public APIs to generate P4Info message. Uses the singleton pattern. More...
class	PackageInstantiation
class	PacketIn
class	PacketOut
class	ParameterSubstitution
class	ParseAnnotationBodies
	Clears a type map after calling a ParseAnnotations instance. More...
class	ParseAnnotations
class	ParserInfo
	Information produced for a parser by the symbolic evaluator. More...
class	ParserInstantiation
class	ParserRewriter
struct	ParserStateInfo
	Information produced for a parser state by the symbolic evaluator. More...
class	ParserStructure
	Information about a parser in the input program. More...
class	ParsersUnroll
struct	PerInstanceSubstitutions
class	Predication
class	ProgramMap
class	ProgramPoint
	Indicates a statement in the program. More...
class	ProgramPoints
class	ReadsWrites
	Computes the SetOfLocations read and written by an expression. More...
class	Reassociation
class	ReferenceMap
	Class used to encode maps from paths to declarations. More...
class	RemoveActionParameters
class	RemoveAliases
class	RemoveAllUnusedDeclarations
	Iterates RemoveUnusedDeclarations until convergence. More...
class	RemoveAssertAssume
class	RemoveComplexComparisons
class	RemoveComplexExpressions
class	RemoveComplexExpressionsPolicy
class	RemoveDontcareArgs
class	RemoveExits
class	RemoveGenericTypes
	Removes all structs or stacks that are generic. More...
class	RemoveHidden
class	RemoveLeftSlices
class	RemoveMiss
class	RemoveNestedStructs
class	RemoveParserControlFlow
class	RemoveParserIfs
class	RemoveRedundantParsers
class	RemoveReturns
class	RemoveSelectBooleans
class	RemoveUnusedActionParameters
class	RemoveUnusedDeclarations
	Removes unused declarations. More...
class	RemoveUnusedHUDeclarations
class	RemoveUnusedPolicy
class	RemoveUselessCasts
class	RenameMap
class	RenameSymbols
class	ReplaceHeaders
class	ReplaceLogMsg
class	ReplacementMap
class	ReplaceSelectRange
class	ReplaceStructs
class	ReplaceTypeUses
class	ResetHeaders
	Invokes TypeChecking followed by DoResetHeaders. More...
class	ResolutionContext
	Visitor mixin for looking up names in enclosing scopes from the Visitor::Context. More...
class	ResolveReferences
class	RewriteAllParsers
class	SameExpression
class	SaturationElim
	Contains utility functions for eliminating saturating arithmetic. More...
class	ScalarValue
class	SerEnumInstance
class	SetHeaders
class	SetOfLocations
class	SideEffectOrdering
class	SideEffects
	Determines whether an expression may have method or constructor invocations. More...
class	SimpleCallInfo
class	SimpleEnumInstance
	An instance of a simple enum, e.g., X.A from enum X { A, B }. More...
class	SimpleInlineList
class	SimpleInlineWorkList
class	SimplifyBitwise
class	SimplifyComparisons
class	SimplifyControlFlow
class	SimplifyDefUse
class	SimplifyKey
class	SimplifyParsers
class	SimplifySelectCases
class	SimplifySelectList
class	SimplifySwitch
class	SingleArgumentSelect
struct	SpecializationInfo
	Describes how a parser or control is specialized. More...
class	SpecializationMap
	Maintains a map from invocation to a SpecializationInfo object. More...
class	Specialize
	Specializes each Parser and Control with constant constructor arguments by substituting type arguments and constructor parameters. More...
class	SpecializeAll
	Specializes each Parser and Control by substituting type arguments and constructor parameters. More...
class	SpecializeFunctions
	Specializes each generic function by substituting type parameters. More...
class	SpecializeGenericFunctions
class	SpecializeGenericTypes
	Specializes each generic type by substituting type parameters. More...
class	StackVariable
class	StackVariableHash
	Class with hash function for StackVariable. More...
class	StaticAssert
class	StorageFactory
class	StorageLocation
	Abstraction for something that is has a left value (variable, parameter) More...
class	StorageMap
	Maps a declaration to its associated storage. More...
class	StrengthReduction
class	StructInitializers
class	StructLocation
struct	StructTypeReplacement
class	SubstituteParameters
class	SubstituteStructures
class	SwitchAddDefault
class	SymbolicArray
class	SymbolicBool
class	SymbolicEnum
class	SymbolicError
class	SymbolicException
class	SymbolicExtern
class	SymbolicHeader
class	SymbolicHeaderUnion
class	SymbolicInteger
class	SymbolicPacketIn
class	SymbolicStaticError
class	SymbolicStruct
class	SymbolicTuple
class	SymbolicValue
class	SymbolicValueFactory
class	SymbolicVarbit
class	SymbolicVoid
class	SymRenameMap
class	SynthesizeActions
class	TableApplySolver
class	TableHit
class	TableInsertions
class	TableKeyNames
class	TablesInActions
class	TablesInKeys
class	TagGlobalActions
class	ToP4
class	TupleLocation
class	TypeChecking
class	TypeConstraint
class	TypeConstraints
class	TypeInference
class	TypeMap
class	TypeOccursVisitor
struct	TypeSpecialization
struct	TypeSpecializationMap
class	TypeSubstitution
class	TypeSubstitutionVisitor
class	TypeUnification
class	TypeVariableSubstitution
class	TypeVariableSubstitutionVisitor
class	UniqueNames
class	UniqueParameters
class	UnnestSelectList
class	UselessCasts
class	ValidateMatchAnnotations
class	ValidateParsedProgram
class	ValidateTableProperties
class	ValidateValueSets
class	ValueMap
struct	VisitedKey
	The main class for parsers' states key for visited checking. More...
class	WithFieldsLocation
	Base class for location sets that contain fields. More...

Typedefs
typedef SimpleCallInfo< IR::P4Action, IR::MethodCallStatement >	ActionCallInfo
typedef SimpleInlineList< IR::P4Action, ActionCallInfo, AInlineWorkList >	ActionsInlineList
typedef SimpleInlineWorkList< IR::P4Action, IR::MethodCallStatement, ActionCallInfo >	AInlineWorkList
typedef SimpleCallInfo< IR::Node, IR::Statement >	FunctionCallInfo
typedef SimpleInlineList< IR::Node, FunctionCallInfo, FunctionsInlineWorkList >	FunctionsInlineList
typedef SimpleInlineWorkList< IR::Node, IR::Statement, FunctionCallInfo >	FunctionsInlineWorkList
using	GeneratedVariablesMap = std::map<cstring, const IR::PathExpression *>
typedef InlineDriver< ActionsInlineList, AInlineWorkList >	InlineActionsDriver
typedef InlineDriver< FunctionsInlineList, FunctionsInlineWorkList >	InlineFunctionsDriver
typedef CallGraph< const IR::ParserState * >	ParserCallGraph
typedef std::unordered_map< StackVariable, const IR::Expression *, StackVariableHash >	StackVariableIndexMap
typedef std::unordered_map< StackVariable, size_t, StackVariableHash >	StackVariableMap
typedef CallGraph< const IR::ParserState * >	StateCallGraph
using	TypeLogMsgParams = std::pair<IR::IndexedVector<IR::NamedExpression>, std::string>

Enumerations
enum class	P4RuntimeFormat { BINARY , JSON , TEXT , TEXT_PROTOBUF }
	P4Runtime serialization formats.
enum class	ResolutionType { Any , Type , TypeVariable }
	Helper class to indicate types of nodes that may be returned during resolution.
enum class	StandardExceptions {   NoError , PacketTooShort , NoMatch , StackOutOfBounds ,   OverwritingHeader , HeaderTooShort , ParserTimeout }
enum class	TernaryBool { Yes , No , Maybe }

Functions
cstring	cgMakeString (char c)
cstring	cgMakeString (const IR::INode *node)
cstring	cgMakeString (const IR::Node *node)
cstring	cgMakeString (cstring s)
void	checkParametersForMap (const IR::ParameterList *params, std::map< cstring, const IR::Expression * > *vars)
void	compareValuesInMaps (std::map< cstring, const IR::Expression * > *oldValues, std::map< cstring, const IR::Expression * > *newValues)
const IR::Expression *	convert (const IR::Expression *expression, const IR::Type *type)
void	dump (P4::TypeVariableSubstitution &tvs)
void	dump (P4::TypeVariableSubstitution *tvs)
void	dumpP4 (const IR::INode *node)
P4RuntimeAPI	generateP4Runtime (const IR::P4Program *program, cstring arch)
const IR::Expression *	getConstant (const ScalarValue *constant)
bool	hasVarbitsOrUnions (const TypeMap *typeMap, const IR::Type *type)
	True if the type contains any varbit or header_union subtypes.
bool	isAsync (const IR::Vector< IR::Method > methods, cstring callee, cstring caller)
bool	isTerminalState (IR::ID id)
bool	names_overlap (cstring name1, cstring name2)
	Test to see if names denote overlapping locations.
std::ostream &	operator<< (std::ostream &out, const ComputeDefUse::defuse_t &du)
std::ostream &	operator<< (std::ostream &out, const ComputeDefUse::loc_t &loc)
std::ostream &	operator<< (std::ostream &out, const std::pair< const IR::Node *, const ordered_set< const ComputeDefUse::loc_t * > > &p)
const IR::Expression *	optimizeExpression (const IR::Expression *node)
template<typename C = P4V1::Converter>
const IR::P4Program *	parseP4File (ParserOptions &options)
const IR::P4Program *	parseP4String (const char *sourceFile, unsigned sourceLine, const std::string &input, CompilerOptions::FrontendVersion version)
const IR::P4Program *	parseP4String (const std::string &input, CompilerOptions::FrontendVersion version)
void	removeVarsContaining (std::map< cstring, const IR::Expression * > *vars, cstring name)
void	serializeP4RuntimeIfRequired (const IR::P4Program *program, const CompilerOptions &options)
std::string	toP4 (const IR::INode *node)
cstring	toString (const TernaryBool &c)
template<typename... T>
void	typeError (const char *format, T... args)
UnparsedConstant	unparsedConstant (const IR::AnnotationToken *token)

Variables
const char	outOfBoundsStateName [] = "stateOutOfBound"
	Name of out of bound state.
std::set< cstring >	reservedWords

Detailed Description

This file has common data structures used for inlining functions and actions. Inlining these is simpler than inlining controls and parsers

---

Class Documentation

P4::TableInsertions

class P4::TableInsertions

Class Members
vector< const Declaration_Variable * >	declarations
vector< const AssignmentStatement * >	statements

Function Documentation

convert()

const IR::Expression * P4::convert	(	const IR::Expression *	expression,
		const IR::Type *	type )

Given an expression and a destination type, convert ListExpressions that occur within expression to StructExpression if the destination type matches.

isTerminalState()

bool P4::isTerminalState

(

IR::ID

id

)

Checks for terminal state.

optimizeExpression()

const IR::Expression * P4::optimizeExpression ( const IR::Expression * node )

inline

Applies expression optimizations to the input node. Currently, performs constant folding and strength reduction.

parseP4File()

template<typename C = P4V1::Converter>

const IR::P4Program * P4::parseP4File

(

ParserOptions &

options

)

Parse P4 source from a file. The filename and language version are specified by @options. If the language version is not P4-16, then the program is converted to P4-16 before being returned.

Returns

a P4-16 IR tree representing the contents of the given file, or null on failure. If failure occurs, an error will also be reported.

parseP4String()

const IR::P4Program * P4::parseP4String	(	const char *	sourceFile,
		unsigned	sourceLine,
		const std::string &	input,
		CompilerOptions::FrontendVersion	version )

Parse P4 source from the string @input, interpreting it as having language version

Version

. The source is not preprocessed before being parsed; the initial source location is derived from @sourceFile and @sourceLine. If the language version is not P4-16, then the program is converted to P4-16 before being returned.

Returns

a P4-16 IR tree representing the contents of the given string, or null on failure. If failure occurs, an error will also be reported.

Variable Documentation

reservedWords

std::set< cstring > P4::reservedWords

Initial value:

= {
    "abstract",  
    "action",     "actions", "apply",  "bool",    "bit",    "const",      "control", "default",
    "else",       "enum",    "error",  "exit",    "extern", "false",      "header",  "header_union",
    "if",         "in",      "inout",  "int",     "key",    "match_kind", "out",     "parser",
    "package",    "return",  "select", "set",     "state",  "struct",     "switch",  "table",
    "this",  
    "transition", "true",    "tuple",  "typedef", "varbit", "verify",     "void",    "_",
    "NoAction"  
}