ScEpTIC.AST.builtins package

Subpackages

• ScEpTIC.AST.builtins.libs package
  • Submodules
  • ScEpTIC.AST.builtins.libs.llvm module
    • address_dimension_16()
    • address_dimension_32()
    • address_dimension_64()
    • get_unaligned_cells()
    • memcpy
      • memcpy.get_val()
    • memmove
      • memmove.get_val()
    • memset
      • memset.get_val()
    • msp430_dma_word_copy
      • msp430_dma_word_copy.get_val()
  • ScEpTIC.AST.builtins.libs.math module
    • abs
      • abs.get_val()
    • acos
      • acos.get_val()
    • asin
      • asin.get_val()
    • atan
      • atan.get_val()
    • atan2
      • atan2.get_val()
    • ceil
      • ceil.get_val()
    • cos
      • cos.get_val()
    • cosh
      • cosh.get_val()
    • exp
      • exp.get_val()
    • fabs
      • fabs.get_val()
    • floor
      • floor.get_val()
    • fmod
      • fmod.get_val()
    • log
      • log.get_val()
    • log10
      • log10.get_val()
    • math_max
      • math_max.get_val()
    • math_min
      • math_min.get_val()
    • pow
      • pow.get_val()
    • sin
      • sin.get_val()
    • sinh
      • sinh.get_val()
    • sqrt
      • sqrt.get_val()
    • tan
      • tan.get_val()
    • tanh
      • tanh.get_val()
  • ScEpTIC.AST.builtins.libs.mem module
    • address_dimension()
    • calloc
      • calloc.get_val()
    • free
      • free.get_val()
    • malloc
      • malloc.get_val()
    • realloc
      • realloc.get_val()
  • ScEpTIC.AST.builtins.libs.sceptic module
    • adc_get_data
      • adc_get_data.get_val()
      • adc_get_data.op_mode_name
    • adc_off
      • adc_off.get_val()
    • adc_on
      • adc_on.get_val()
    • adc_read
      • adc_read.get_val()
    • camera_read_data
      • camera_read_data.get_val()
    • cc1101_set_state
      • cc1101_set_state.get_val()
      • cc1101_set_state.states
    • cc1101_transmit
      • cc1101_transmit.get_val()
    • generic_adc_sensor_read
      • generic_adc_sensor_read.get_val()
    • get_capacitor_voltage
      • get_capacitor_voltage.get_val()
    • get_mcu_clock_cycles
      • get_mcu_clock_cycles.get_val()
    • get_mcu_time
      • get_mcu_time.get_val()
    • get_mcu_time_us
      • get_mcu_time_us.get_val()
    • get_simulation_time
      • get_simulation_time.get_val()
      • get_simulation_time.print_enabled
    • get_used_energy
      • get_used_energy.get_val()
      • get_used_energy.print_enabled
    • reset_simulation_time
      • reset_simulation_time.get_val()
    • reset_used_energy
      • reset_used_energy.get_val()
    • set_capacitor_voltage
      • set_capacitor_voltage.get_val()
    • set_mcu_power_on_voltage
      • set_mcu_power_on_voltage.get_val()
    • set_mcu_time
      • set_mcu_time.get_val()
    • set_mcu_time_us
      • set_mcu_time_us.get_val()
    • temperature_read_data
      • temperature_read_data.get_val()
    • timekeeper_get_time
      • timekeeper_get_time.get_val()
    • timekeeper_get_time_us
      • timekeeper_get_time_us.get_val()
    • voc_read_data
      • voc_read_data.get_val()
  • ScEpTIC.AST.builtins.libs.std module
    • debug_print
      • debug_print.get_val()
    • exitbuiltin
      • exitbuiltin.get_val()
    • memcmp
      • memcmp.get_val()
    • randombuiltin
      • randombuiltin.get_val()
    • srandombuiltin
      • srandombuiltin.get_val()
    • strlen
      • strlen.get_val()
    • timebuiltin
      • timebuiltin.get_val()
  • Module contents

Submodules

ScEpTIC.AST.builtins.builtin module

class ScEpTIC.AST.builtins.builtin.Builtin

Bases: Instruction

Base object to be extended for builtin functions.

HOW TO:

1. create the new instruction to be executed

2. Implement the get_val() method, returning the result of the instruction.

   Arguments can be obatined using the list self.args (index = index of arg), their values will be automatically resolved on runtime.

3. Call the class method define_builtin on the class

4. All the builtins will be loaded by calling link()

Example:

class LenTestInstruction(Builtin):

def get_val(self):

return len(self.args)

LenTestInstruction.define_builtin(‘let_test_instruction’, ‘i32, i32, double, float, i8’, ‘i64’)

property args

Returns the resolved value of the arguments.

builtins = [{'arguments': <function address_dimension_16>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memcpy'>, 'name': 'llvm.memcpy.p0i8.p0i8.i16', 'return_type': 'void'}, {'arguments': <function address_dimension_32>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memcpy'>, 'name': 'llvm.memcpy.p0i8.p0i8.i32', 'return_type': 'void'}, {'arguments': <function address_dimension_64>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memcpy'>, 'name': 'llvm.memcpy.p0i8.p0i8.i64', 'return_type': 'void'}, {'arguments': <function address_dimension_16>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memmove'>, 'name': 'llvm.memmove.p0i8.p0i8.i16', 'return_type': 'void'}, {'arguments': <function address_dimension_32>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memmove'>, 'name': 'llvm.memmove.p0i8.p0i8.i32', 'return_type': 'void'}, {'arguments': <function address_dimension_64>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memmove'>, 'name': 'llvm.memmove.p0i8.p0i8.i64', 'return_type': 'void'}, {'arguments': <function address_dimension_16>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memset'>, 'name': 'llvm.memset.p0i8.i16', 'return_type': 'void'}, {'arguments': <function address_dimension_32>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memset'>, 'name': 'llvm.memset.p0i8.i32', 'return_type': 'void'}, {'arguments': <function address_dimension_64>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memset'>, 'name': 'llvm.memset.p0i8.i64', 'return_type': 'void'}, {'arguments': <function address_dimension_64>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.memcpy'>, 'name': '__memcpy_chk', 'return_type': 'void'}, {'arguments': <function address_dimension_32>, 'instruction': <class 'ScEpTIC.AST.builtins.libs.llvm.msp430_dma_word_copy'>, 'name': '__dma_word_copy', 'return_type': 'void'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.ceil'>, 'name': 'ceil', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.ceil'>, 'name': 'llvm.ceil.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.floor'>, 'name': 'floor', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.floor'>, 'name': 'llvm.floor.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.fabs'>, 'name': 'fabs', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.fabs'>, 'name': 'llvm.fabs.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.abs'>, 'name': 'abs', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.abs'>, 'name': 'llvm.abs.f64', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.fmod'>, 'name': 'fmod', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.fmod'>, 'name': 'llvm.fmod.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sqrt'>, 'name': 'sqrt', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sqrt'>, 'name': 'llvm.sqrt.f64', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.pow'>, 'name': 'pow', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.pow'>, 'name': 'llvm.pow.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.exp'>, 'name': 'exp', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.exp'>, 'name': 'llvm.exp.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.log'>, 'name': 'log', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.log'>, 'name': 'llvm.log.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.log10'>, 'name': 'log10', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.log10'>, 'name': 'llvm.log10.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.acos'>, 'name': 'acos', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.acos'>, 'name': 'llvm.acos.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.asin'>, 'name': 'asin', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.asin'>, 'name': 'llvm.asin.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.atan'>, 'name': 'atan', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.atan'>, 'name': 'llvm.atan.f64', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.atan2'>, 'name': 'atan2', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.atan2'>, 'name': 'llvm.atan2.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.cos'>, 'name': 'cos', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.cos'>, 'name': 'llvm.cos.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.cosh'>, 'name': 'cosh', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.cosh'>, 'name': 'llvm.cosh.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sin'>, 'name': 'sin', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sin'>, 'name': 'llvm.sin.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sinh'>, 'name': 'sinh', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.sinh'>, 'name': 'llvm.sinh.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.tan'>, 'name': 'tan', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.tan'>, 'name': 'llvm.tan.f64', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.tanh'>, 'name': 'tanh', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.tanh'>, 'name': 'llvm.tanh.f64', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.math_max'>, 'name': 'MAX', 'return_type': 'double'}, {'arguments': 'double, double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.math.math_min'>, 'name': 'MAX', 'return_type': 'double'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.mem.malloc'>, 'name': 'malloc', 'return_type': <function address_dimension>}, {'arguments': 'i32, i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.mem.calloc'>, 'name': 'calloc', 'return_type': <function address_dimension>}, {'arguments': '<function address_dimension>, i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.mem.realloc'>, 'name': 'realloc', 'return_type': <function address_dimension>}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.mem.free'>, 'name': 'free', 'return_type': <function address_dimension>}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_capacitor_voltage'>, 'name': 'sceptic_get_capacitor_voltage', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.set_capacitor_voltage'>, 'name': 'sceptic_set_capacitor_voltage', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_mcu_clock_cycles'>, 'name': 'sceptic_get_mcu_clock_cycles', 'return_type': 'i32'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_mcu_time'>, 'name': 'sceptic_get_mcu_time', 'return_type': 'double'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_mcu_time_us'>, 'name': 'sceptic_get_mcu_time_us', 'return_type': 'double'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_used_energy'>, 'name': 'sceptic_get_used_energy', 'return_type': 'double'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.reset_used_energy'>, 'name': 'sceptic_reset_used_energy', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.get_simulation_time'>, 'name': 'sceptic_get_simulation_time', 'return_type': 'double'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.set_mcu_time'>, 'name': 'sceptic_set_mcu_time', 'return_type': 'void'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.set_mcu_time_us'>, 'name': 'sceptic_set_mcu_time_us', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.reset_simulation_time'>, 'name': 'sceptic_reset_simulation_time', 'return_type': 'void'}, {'arguments': 'double', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.set_mcu_power_on_voltage'>, 'name': 'sceptic_set_mcu_power_on_voltage', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.timekeeper_get_time'>, 'name': 'sceptic_timekeeper_get_time', 'return_type': 'double'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.timekeeper_get_time_us'>, 'name': 'sceptic_timekeeper_get_time_us', 'return_type': 'double'}, {'arguments': 'i32, double, i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.adc_get_data'>, 'name': 'sceptic_adc_get_data', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.adc_on'>, 'name': 'sceptic_adc_on', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.adc_off'>, 'name': 'sceptic_adc_off', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.adc_read'>, 'name': 'sceptic_adc_read', 'return_type': 'void'}, {'arguments': 'i32, i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.cc1101_transmit'>, 'name': 'sceptic_cc1101_transmit', 'return_type': 'void'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.cc1101_set_state'>, 'name': 'sceptic_cc1101_set_state', 'return_type': 'void'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.generic_adc_sensor_read'>, 'name': 'sceptic_generic_adc_sensor_read', 'return_type': 'void'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.camera_read_data'>, 'name': 'sceptic_camera_read_data', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.temperature_read_data'>, 'name': 'sceptic_read_temperature', 'return_type': 'void'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.sceptic.voc_read_data'>, 'name': 'sceptic_read_voc', 'return_type': 'void'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.debug_print'>, 'name': 'debug_print', 'return_type': 'void'}, {'arguments': 'i8, i8, i64', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.memcmp'>, 'name': 'memcmp', 'return_type': 'i32'}, {'arguments': 'i8, i8, i64', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.memcmp'>, 'name': 'strncmp', 'return_type': 'i32'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.randombuiltin'>, 'name': 'rand', 'return_type': 'i32'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.srandombuiltin'>, 'name': 'srand', 'return_type': 'void'}, {'arguments': 'i32', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.exitbuiltin'>, 'name': 'exit', 'return_type': 'void'}, {'arguments': 'i8', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.strlen'>, 'name': 'strlen', 'return_type': 'i64'}, {'arguments': '', 'instruction': <class 'ScEpTIC.AST.builtins.libs.std.timebuiltin'>, 'name': 'time', 'return_type': 'i32'}]

classmethod define_builtin(name, arguments, return_type)

Define builtins, which will be loaded by the link() function.

get_uses()

Returns the registers used by this instruction as a list of strings. (used by register allocation)

get_val()

NB: must be implemented by each builtin!

static link()

Links the builtin Instructions creating a function.

replace_reg_name(old_reg_name, new_reg_name)

Replaces the name of a register used by the instruction with a new one. (used by register allocation)

set_args(args)

Sets the arguments of the builtin.

tick_count = 1

ScEpTIC.AST.builtins.linker module

class ScEpTIC.AST.builtins.linker.BuiltinLinker(name, arguments, return_type, instruction)

Bases: object

This class generates the code of a builtin function. Builtin functions are implementation of library functions (e.g. sqrt, pow) that performs some architecture-dependent operations, which doesn’t modify the control flow nor the memory (SRAM, NVM).

In case control-flow modification or memory accesses are needed, it is better to directly create some C code for them and include it in the final code to be analyzed.

Builtins are just used to not include in the final code library operations, and should not be used to emulate memory accesses, global variables accesses, direct-memory writes and other major operations, which can be easily implemented in the program code.

An example of a builtins are mathematical functions and printing functions.

The core of a builtin is an extension of the Instruction operation. This is needed to be able to analyze the code.

Normally LLVM will consider the arguments to be from virtual register %0 to %(#args - 1) and the %(#args) is the ID of the first basic block. Since the builtins should not have labels and control-flow operations, it is omitted.

Arguments are passed from %0 to %(len(args) - 1) Arguments addresses in stack are stored from %(len(args)) to %(len(args)*2 - 1) Arguments values are loaded from %(len(args) * 2) to %(len(args) * 3 - 1) Return value will be on %(len(args) * 3)

prefix = None

Module contents

ScEpTIC.AST.builtins.link_builtins()

Links the builtins (both library-defined and user-defined)

ScEpTIC.AST.builtins.load_libraries()

Loads the libraries of builtins