def __init__(self, hlirParser): # hlirParser is a P4 parser

self.parser = hlirParser

self.name = hlirParser.name

def serialize(self, serializer, program):

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

serializer.emitIndent()

serializer.appendFormat("{0}: ", self.name)

serializer.blockStart()

for op in self.parser.call_sequence:

self.serializeOperation(serializer, op, program)

self.serializeBranch(serializer, self.parser.branch_on,

self.parser.branch_to, program)

serializer.blockEnd(True)

def serializeSelect(self, selectVarName, serializer, branch_on, program):

# selectVarName - name of temp variable to use for the select expression

assert isinstance(selectVarName, str)

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

totalWidth = 0

switchValue = ""

for e in branch_on:

if isinstance(e, p4_field):

instance = e.instance

assert isinstance(instance, p4_header_instance)

index = ""

if ebpfProgram.EbpfProgram.isArrayElementInstance(instance):

ebpfStack = program.getStackInstance(instance.base_name)

assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack)

if isinstance(instance.index, int):

index = "[" + str(instance.index) + "]"

elif instance.index is P4_NEXT:

index = "[" + ebpfStack.indexVar + "]"

else:

raise CompilationException(True,

"Unexpected index for array {0}", instance.index)

basetype = ebpfStack.basetype

name = ebpfStack.name

else:

ebpfHeader = program.getInstance(instance.name)

assert isinstance(ebpfHeader, ebpfInstance.EbpfHeader)

basetype = ebpfHeader.type

name = ebpfHeader.name

ebpfField = basetype.getField(e.name)

assert isinstance(ebpfField, ebpfStructType.EbpfField)

totalWidth += ebpfField.widthInBits()

fieldReference = (program.headerStructName + "." + name +

index + "." + ebpfField.name)

if switchValue == "":

switchValue = fieldReference

else:

switchValue = ("(" + switchValue + " << " +

str(ebpfField.widthInBits()) + ")")

switchValue = switchValue + " | " + fieldReference

elif isinstance(e, tuple):

switchValue = self.currentReferenceAsString(e, program)

else:

raise CompilationException(

True, "Unexpected element in match {0}", e)

if totalWidth > 32:

raise NotSupportedException("{0}: Matching on {1}-bit value",

branch_on, totalWidth)

serializer.emitIndent()

serializer.appendFormat("{0}32 {1} = {2};",

program.config.uprefix,

selectVarName, switchValue)

serializer.newline()

def generatePacketLoad(self, startBit, width, alignment, program):

# Generates an expression that does a load_*, shift and mask

# to load 'width' bits starting at startBit from the current

# packet offset.

# alignment is an integer <= 8 that holds the current alignment

# of of the packet offset.

assert width > 0

assert alignment < 8

assert isinstance(startBit, int)

assert isinstance(width, int)

assert isinstance(alignment, int)

firstBitIndex = startBit + alignment

lastBitIndex = startBit + width + alignment - 1

firstWordIndex = firstBitIndex / 8

lastWordIndex = lastBitIndex / 8

wordsToRead = lastWordIndex - firstWordIndex + 1

if wordsToRead == 1:

load = "load_byte"

loadSize = 8

elif wordsToRead == 2:

load = "load_half"

loadSize = 16

elif wordsToRead <= 4:

load = "load_word"

loadSize = 32

elif wordsToRead <= 8:

load = "load_dword"

loadSize = 64

else:

raise CompilationException(True, "Attempt to load more than 1 word")

readtype = program.config.uprefix + str(loadSize)

loadInstruction = "{0}({1}, ({2} + {3}) / 8)".format(

load, program.packetName, program.offsetVariableName, startBit)

shift = loadSize - alignment - width

load = "(({0}) >> ({1}))".format(loadInstruction, shift)

if width != loadSize:

mask = " & EBPF_MASK({0}, {1})".format(readtype, width)

else:

mask = ""

return load + mask

def currentReferenceAsString(self, tpl, program):

# a string describing an expression of the form current(position, width)

# The assumption is that at this point the packet cursor is ALWAYS

# byte aligned. This should be true because headers are supposed

# to have sizes an integral number of bytes.

assert isinstance(tpl, tuple)

if len(tpl) != 2:

raise CompilationException(

True, "{0} Expected a tuple with 2 elements", tpl)

minIndex = tpl[0]

totalWidth = tpl[1]

result = self.generatePacketLoad(

minIndex, totalWidth, 0, program) # alignment is 0

return result

def serializeCases(self, selectVarName, serializer, branch_to, program):

assert isinstance(selectVarName, str)

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

branches = 0

seenDefault = False

for e in branch_to.keys():

serializer.emitIndent()

value = branch_to[e]

if isinstance(e, int):

serializer.appendFormat("if ({0} == {1})", selectVarName, e)

elif isinstance(e, tuple):

serializer.appendFormat(

"if (({0} & {1}) == {2})", selectVarName, e[0], e[1])

elif isinstance(e, p4_parse_value_set):

raise NotSupportedException("{0}: Parser value sets", e)

elif e is P4_DEFAULT:

seenDefault = True

if branches > 0:

serializer.append("else")

else:

raise CompilationException(

True, "Unexpected element in match case {0}", e)

branches += 1

serializer.newline()

serializer.increaseIndent()

serializer.emitIndent()

label = program.getLabel(value)

if isinstance(value, p4_parse_state):

serializer.appendFormat("goto {0};", label)

elif isinstance(value, p4_table):

serializer.appendFormat("goto {0};", label)

elif isinstance(value, p4_conditional_node):

serializer.appendFormat("goto {0};", label)

elif isinstance(value, p4_parser_exception):

raise CompilationException(True, "Not yet implemented")

else:

raise CompilationException(

True, "Unexpected element in match case {0}", value)

serializer.decreaseIndent()

serializer.newline()

# Must create default if it is missing

if not seenDefault:

serializer.emitIndent()

serializer.appendFormat(

"{0} = p4_pe_unhandled_select;", program.errorName)

serializer.newline()

serializer.emitIndent()

serializer.appendFormat("default: goto end;")

serializer.newline()

def serializeBranch(self, serializer, branch_on, branch_to, program):

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

if branch_on == []:

dest = branch_to.values()[0]

serializer.emitIndent()

name = program.getLabel(dest)

serializer.appendFormat("goto {0};", name)

serializer.newline()

elif isinstance(branch_on, list):

tmpvar = program.generateNewName("tmp")

self.serializeSelect(tmpvar, serializer, branch_on, program)

self.serializeCases(tmpvar, serializer, branch_to, program)

else:

raise CompilationException(

True, "Unexpected branch_on {0}", branch_on)

def serializeOperation(self, serializer, op, program):

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

operation = op[0]

if operation is parse_call.extract:

self.serializeExtract(serializer, op[1], program)

elif operation is parse_call.set:

self.serializeMetadataSet(serializer, op[1], op[2], program)

else:

raise CompilationException(

True, "Unexpected operation in parser {0}", op)

def serializeFieldExtract(self, serializer, headerInstanceName,

index, field, alignment, program):

assert isinstance(index, str)

assert isinstance(headerInstanceName, str)

assert isinstance(field, ebpfStructType.EbpfField)

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(alignment, int)

assert isinstance(program, ebpfProgram.EbpfProgram)

fieldToExtractTo = headerInstanceName + index + "." + field.name

serializer.emitIndent()

width = field.widthInBits()

if field.name == "valid":

serializer.appendFormat(

"{0}.{1} = 1;", program.headerStructName, fieldToExtractTo)

serializer.newline()

return

serializer.appendFormat("if ({0}->len < BYTES({1} + {2})) ",

program.packetName,

program.offsetVariableName, width)

serializer.blockStart()

serializer.emitIndent()

serializer.appendFormat("{0} = p4_pe_header_too_short;",

program.errorName)

serializer.newline()

serializer.emitIndent()

serializer.appendLine("goto end;")

# TODO: jump to correct exception handler

serializer.blockEnd(True)

if width <= 32:

serializer.emitIndent()

load = self.generatePacketLoad(0, width, alignment, program)

serializer.appendFormat("{0}.{1} = {2};",

program.headerStructName,

fieldToExtractTo, load)

serializer.newline()

else:

# Destination is bigger than 4 bytes and

# represented as a byte array.

if alignment == 0:

shift = 0

else:

shift = 8 - alignment

assert shift >= 0

if shift == 0:

method = "load_byte"

else:

method = "load_half"

b = (width + 7) / 8

for i in range(0, b):

serializer.emitIndent()

serializer.appendFormat("{0}.{1}[{2}] = ({3}8)",

program.headerStructName,

fieldToExtractTo, i,

program.config.uprefix)

serializer.appendFormat("(({0}({1}, ({2} / 8) + {3}) >> {4})",

method, program.packetName,

program.offsetVariableName, i, shift)

if (i == b - 1) and (width % 8 != 0):

serializer.appendFormat(" & EBPF_MASK({0}8, {1})",

program.config.uprefix, width % 8)

serializer.append(")")

serializer.endOfStatement(True)

serializer.emitIndent()

serializer.appendFormat("{0} += {1};",

program.offsetVariableName, width)

serializer.newline()

def serializeExtract(self, serializer, headerInstance, program):

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(headerInstance, p4_header_instance)

assert isinstance(program, ebpfProgram.EbpfProgram)

if ebpfProgram.EbpfProgram.isArrayElementInstance(headerInstance):

ebpfStack = program.getStackInstance(headerInstance.base_name)

assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack)

# write bounds check

serializer.emitIndent()

serializer.appendFormat("if ({0} >= {1}) ",

ebpfStack.indexVar, ebpfStack.arraySize)

serializer.blockStart()

serializer.emitIndent()

serializer.appendFormat("{0} = p4_pe_index_out_of_bounds;",

program.errorName)

serializer.newline()

serializer.emitIndent()

serializer.appendLine("goto end;")

serializer.blockEnd(True)

if isinstance(headerInstance.index, int):

index = "[" + str(headerInstance.index) + "]"

elif headerInstance.index is P4_NEXT:

index = "[" + ebpfStack.indexVar + "]"

else:

raise CompilationException(

True, "Unexpected index for array {0}",

headerInstance.index)

basetype = ebpfStack.basetype

else:

ebpfHeader = program.getHeaderInstance(headerInstance.name)

basetype = ebpfHeader.type

index = ""

# extract all fields

alignment = 0

for field in basetype.fields:

assert isinstance(field, ebpfStructType.EbpfField)

self.serializeFieldExtract(serializer, headerInstance.base_name,

index, field, alignment, program)

alignment += field.widthInBits()

alignment = alignment % 8

if ebpfProgram.EbpfProgram.isArrayElementInstance(headerInstance):

# increment stack index

ebpfStack = program.getStackInstance(headerInstance.base_name)

assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack)

# write bounds check

serializer.emitIndent()

serializer.appendFormat("{0}++;", ebpfStack.indexVar)

serializer.newline()

def serializeMetadataSet(self, serializer, field, value, program):

assert isinstance(serializer, programSerializer.ProgramSerializer)

assert isinstance(program, ebpfProgram.EbpfProgram)

assert isinstance(field, p4_field)

dest = program.getInstance(field.instance.name)

assert isinstance(dest, ebpfInstance.SimpleInstance)

destType = dest.type

assert isinstance(destType, ebpfStructType.EbpfStructType)

destField = destType.getField(field.name)

if destField.widthInBits() > 32:

useMemcpy = True

bytesToCopy = destField.widthInBits() / 8

if destField.widthInBits() % 8 != 0:

raise CompilationException(

True,

"{0}: Not implemented: wide field w. sz not multiple of 8",

field)

else:

useMemcpy = False

bytesToCopy = None # not needed, but compiler is confused

serializer.emitIndent()

destination = "{0}.{1}.{2}".format(

program.metadataStructName, dest.name, destField.name)

if isinstance(value, int):

source = str(value)

if useMemcpy:

raise CompilationException(

True,

"{0}: Not implemented: copying from wide constant",

value)

elif isinstance(value, tuple):

source = self.currentReferenceAsString(value, program)

elif isinstance(value, p4_field):

source = program.getInstance(value.instance.name)

if isinstance(source, ebpfInstance.EbpfMetadata):

sourceStruct = program.metadataStructName

else:

sourceStruct = program.headerStructName

source = "{0}.{1}.{2}".format(sourceStruct, source.name, value.name)

else:

raise CompilationException(

True, "Unexpected type for parse_call.set {0}", value)

if useMemcpy:

serializer.appendFormat("memcpy(&{0}, &{1}, {2})",

destination, source, bytesToCopy)

else:

serializer.appendFormat("{0} = {1}", destination, source)