# Copyright (c) Barefoot Networks, Inc.
# Licensed under the Apache License, Version 2.0 (the "License")
from p4_hlir.hlir import p4_action, p4_field
from p4_hlir.hlir import p4_signature_ref, p4_header_instance
import ebpfProgram
from programSerializer import ProgramSerializer
from compilationException import *
import ebpfScalarType
import ebpfCounter
import ebpfType
import ebpfInstance
class EbpfActionData(object):
def __init__(self, name, argtype):
self.name = name
self.argtype = argtype
class EbpfActionBase(object):
def __init__(self, p4action):
self.name = p4action.name
self.hliraction = p4action
self.builtin = False
self.arguments = []
def serializeArgumentsAsStruct(self, serializer):
serializer.emitIndent()
serializer.appendFormat("/* no arguments for {0} */", self.name)
serializer.newline()
def serializeBody(self, serializer, valueName, program):
serializer.emitIndent()
serializer.appendFormat("/* no body for {0} */", self.name)
serializer.newline()
def __str__(self):
return "EbpfAction({0})".format(self.name)
class EbpfAction(EbpfActionBase):
unsupported = [
# The following cannot be done in EBPF
"add_header", "remove_header", "execute_meter",
"clone_ingress_pkt_to_egress",
"clone_egress_pkt_to_egress", "generate_digest", "resubmit",
"modify_field_with_hash_based_offset", "truncate", "push", "pop",
# The following could be done, but are not yet implemented
# The situation with copy_header is complicated,
# because we don't do checksums
"copy_header", "count",
"register_read", "register_write"]
# noinspection PyUnresolvedReferences
def __init__(self, p4action, program):
super(EbpfAction, self).__init__(p4action)
assert isinstance(p4action, p4_action)
assert isinstance(program, ebpfProgram.EbpfProgram)
self.builtin = False
self.invalid = False # a leaf action which is never
# called from a table can be invalid.
for i in range(0, len(p4action.signature)):
param = p4action.signature[i]
width = p4action.signature_widths[i]
if width is None:
self.invalid = True
return
argtype = ebpfScalarType.EbpfScalarType(p4action, width,
False, program.config)
actionData = EbpfActionData(param, argtype)
self.arguments.append(actionData)
def serializeArgumentsAsStruct(self, serializer):
if self.invalid:
raise CompilationException(True,
"{0} Attempting to generate code for an invalid action",
self.hliraction)
# Build a struct containing all action arguments.
serializer.emitIndent()
serializer.append("struct ")
serializer.blockStart()
assert isinstance(serializer, ProgramSerializer)
for arg in self.arguments:
assert isinstance(arg, EbpfActionData)
serializer.emitIndent()
argtype = arg.argtype
assert isinstance(argtype, ebpfType.EbpfType)
argtype.declare(serializer, arg.name, False)
serializer.endOfStatement(True)
serializer.blockEnd(False)
serializer.space()
serializer.append(self.name)
serializer.endOfStatement(True)
def serializeBody(self, serializer, dataContainer, program):
if self.invalid:
raise CompilationException(True,
"{0} Attempting to generate code for an invalid action",
self.hliraction)
# TODO: generate PARALLEL implementation
# dataContainer is a string containing the variable name
# containing the action data
assert isinstance(serializer, ProgramSerializer)
assert isinstance(program, ebpfProgram.EbpfProgram)
assert isinstance(dataContainer, str)
callee_list = self.hliraction.flat_call_sequence
for e in callee_list:
action = e[0]
assert isinstance(action, p4_action)
arguments = e[1]
assert isinstance(arguments, list)
self.serializeCallee(self, action, arguments, serializer,
dataContainer, program)
def checkSize(self, call, args, program):
size = None
for a in args:
if a is None:
continue
if size is None:
size = a
elif a != size:
program.emitWarning(
"{0}: Arguments do not have the same size {1} and {2}",
call, size, a)
return size
@staticmethod
def translateActionToOperator(actionName):
if actionName == "add" or actionName == "add_to_field":
return "+"
elif actionName == "bit_and":
return "&"
elif actionName == "bit_or":
return "|"
elif actionName == "bit_xor":
return "^"
elif actionName == "subtract" or actionName == "subtract_from_field":
return "-"
else:
raise CompilationException(True,
"Unexpected primitive action {0}",
actionName)
def serializeCount(self, caller, arguments, serializer,
dataContainer, program):
assert isinstance(serializer, ProgramSerializer)
assert isinstance(program, ebpfProgram.EbpfProgram)
assert isinstance(arguments, list)
assert len(arguments) == 2
counter = arguments[0]
index = ArgInfo(arguments[1], caller, dataContainer, program)
ctr = program.getCounter(counter.name)
assert isinstance(ctr, ebpfCounter.EbpfCounter)
serializer.emitIndent()
serializer.blockStart()
# This is actually incorrect, since the key is not always an u32.
# This code is currently disabled
key = program.reservedPrefix + "index"
serializer.emitIndent()
serializer.appendFormat("u32 {0} = {1};", key, index.asString)
serializer.newline()
ctr.serializeCode(key, serializer, program)
serializer.blockEnd(True)
def serializeCallee(self, caller, callee, arguments,
serializer, dataContainer, program):
if self.invalid:
raise CompilationException(
True,
"{0} Attempting to generate code for an invalid action",
self.hliraction)
assert isinstance(serializer, ProgramSerializer)
assert isinstance(program, ebpfProgram.EbpfProgram)
assert isinstance(callee, p4_action)
assert isinstance(arguments, list)
if callee.name in EbpfAction.unsupported:
raise NotSupportedException("{0}", callee)
# This is not yet ready
#if callee.name == "count":
# self.serializeCount(caller, arguments,
# serializer, dataContainer, program)
# return
serializer.emitIndent()
args = self.transformArguments(arguments, caller,
dataContainer, program)
if callee.name == "modify_field":
dst = args[0]
src = args[1]
size = self.checkSize(callee,
[a.widthInBits() for a in args],
program)
if size is None:
raise CompilationException(
True, "Cannot infer width for arguments {0}",
callee)
elif size <= 32:
serializer.appendFormat("{0} = {1};",
dst.asString,
src.asString)
else:
if not dst.isLvalue:
raise NotSupportedException(
"Constants wider than 32-bit: {0}({1})",
dst.caller, dst.asString)
if not src.isLvalue:
raise NotSupportedException(
"Constants wider than 32-bit: {0}({1})",
src.caller, src.asString)
serializer.appendFormat("memcpy(&{0}, &{1}, {2});",
dst.asString,
src.asString,
size / 8)
elif (callee.name == "add" or
callee.name == "bit_and" or
callee.name == "bit_or" or
callee.name == "bit_xor" or
callee.name == "subtract"):
size = self.checkSize(callee,
[a.widthInBits() for a in args],
program)
if size is None:
raise CompilationException(
True,
"Cannot infer width for arguments {0}",
callee)
if size > 32:
raise NotSupportedException("{0}: Arithmetic on {1}-bits",
callee, size)
op = EbpfAction.translateActionToOperator(callee.name)
serializer.appendFormat("{0} = {1} {2} {3};",
args[0].asString,
args[1].asString,
op,
args[2].asString)
elif (callee.name == "add_to_field" or
callee.name == "subtract_from_field"):
size = self.checkSize(callee,
[a.widthInBits() for a in args],
program)
if size is None:
raise CompilationException(
True, "Cannot infer width for arguments {0}", callee)
if size > 32:
raise NotSupportedException(
"{0}: Arithmetic on {1}-bits", callee, size)
op = EbpfAction.translateActionToOperator(callee.name)
serializer.appendFormat("{0} = {0} {1} {2};",
args[0].asString,
op,
args[1].asString)
elif callee.name == "no_op":
serializer.append("/* noop */")
elif callee.name == "drop":
serializer.appendFormat("{0} = 1;", program.dropBit)
elif callee.name == "push" or callee.name == "pop":
raise CompilationException(
True, "{0} push/pop not yet implemented", callee)
else:
raise CompilationException(
True, "Unexpected primitive action {0}", callee)
serializer.newline()
def transformArguments(self, arguments, caller, dataContainer, program):
result = []
for a in arguments:
t = ArgInfo(a, caller, dataContainer, program)
result.append(t)
return result
class BuiltinAction(EbpfActionBase):
def __init__(self, p4action):
super(BuiltinAction, self).__init__(p4action)
self.builtin = True
def serializeBody(self, serializer, valueName, program):
# This is ugly; there should be a better way
if self.name == "drop":
serializer.emitIndent()
serializer.appendFormat("{0} = 1;", program.dropBit)
serializer.newline()
else:
serializer.emitIndent()
serializer.appendFormat("/* no body for {0} */", self.name)
serializer.newline()
class ArgInfo(object):
# noinspection PyUnresolvedReferences
# Represents an argument passed to an action
def __init__(self, argument, caller, dataContainer, program):
self.width = None
self.asString = None
self.isLvalue = True
self.caller = caller
assert isinstance(program, ebpfProgram.EbpfProgram)
assert isinstance(caller, EbpfAction)
if isinstance(argument, int):
self.asString = str(argument)
self.isLvalue = False
# size is unknown
elif isinstance(argument, p4_field):
if ebpfProgram.EbpfProgram.isArrayElementInstance(
argument.instance):
if isinstance(argument.instance.index, int):
index = "[" + str(argument.instance.index) + "]"
else:
raise CompilationException(
True,
"Unexpected index for array {0}",
argument.instance.index)
stackInstance = program.getStackInstance(
argument.instance.base_name)
assert isinstance(stackInstance, ebpfInstance.EbpfHeaderStack)
fieldtype = stackInstance.basetype.getField(argument.name)
self.width = fieldtype.widthInBits()
self.asString = "{0}.{1}{3}.{2}".format(
program.headerStructName,
stackInstance.name, argument.name, index)
else:
instance = program.getInstance(argument.instance.base_name)
if isinstance(instance, ebpfInstance.EbpfHeader):
parent = program.headerStructName
else:
parent = program.metadataStructName
fieldtype = instance.type.getField(argument.name)
self.width = fieldtype.widthInBits()
self.asString = "{0}.{1}.{2}".format(
parent, instance.name, argument.name)
elif isinstance(argument, p4_signature_ref):
refarg = caller.arguments[argument.idx]
self.asString = "{0}->u.{1}.{2}".format(
dataContainer, caller.name, refarg.name)
self.width = caller.arguments[argument.idx].argtype.widthInBits()
elif isinstance(argument, p4_header_instance):
# This could be a header array element
# Unfortunately for push and pop, the user mean the whole array,
# but the representation contains just the first element here.
# This looks like a bug in the HLIR.
if ebpfProgram.EbpfProgram.isArrayElementInstance(argument):
if isinstance(argument.index, int):
index = "[" + str(argument.index) + "]"
else:
raise CompilationException(
True,
"Unexpected index for array {0}", argument.index)
stackInstance = program.getStackInstance(argument.base_name)
assert isinstance(stackInstance, ebpfInstance.EbpfHeaderStack)
fieldtype = stackInstance.basetype
self.width = fieldtype.widthInBits()
self.asString = "{0}.{1}{2}".format(
program.headerStructName, stackInstance.name, index)
else:
instance = program.getInstance(argument.name)
instancetype = instance.type
self.width = instancetype.widthInBits()
self.asString = "{0}.{1}".format(
program.headerStructName, argument.name)
else:
raise CompilationException(
True, "Unexpected action argument {0}", argument)
def widthInBits(self):
return self.width