#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "assert.h"
#include "util.h"
#include "vpr_types.h"
#include "globals.h"
#include "read_sdc.h"
#include "read_blif.h"
#include "path_delay.h"
#include "path_delay2.h"
#include "ReadOptions.h"
#include "slre.h"

Include dependency graph for read_sdc.c:

Data Structures
struct	s_sdc_clock

struct	s_sdc_exclusive_group

Macros
#define	SDC_TOKENS " \t\n{}[]" /* We can ignore braces. */

Typedefs
typedef struct s_sdc_clock	t_sdc_clock

typedef struct s_sdc_exclusive_group	t_sdc_exclusive_group

Functions
static void	alloc_and_load_netlist_clocks_and_ios (void)

static void	use_default_timing_constraints (void)

static void	count_netlist_clocks_as_constrained_clocks (void)

static boolean	get_sdc_tok (char *buf)

static boolean	is_number (char *ptr)

static int	find_constrained_clock (char *ptr)

static float	calculate_constraint (t_sdc_clock source_domain, t_sdc_clock sink_domain)

static void	add_override_constraint (char from_list, int num_from, char to_list, int num_to, float constraint, int num_multicycles, boolean domain_level_from, boolean domain_level_to, boolean make_copies)

static int	find_cc_constraint (char source_clock_domain, char sink_clock_domain)

static boolean	regex_match (char string, char pattern)

static void	count_netlist_ios_as_constrained_ios (char *clock_name, float io_delay)

static void	free_io_constraint (t_io *&io_array, int num_ios)

static void	free_clock_constraint (t_clock *&clock_array, int num_clocks)

void	read_sdc (t_timing_inf timing_inf)

void	free_sdc_related_structs (void)

void	free_override_constraint (t_override_constraint *&constraint_array, int num_constraints)

Variables
t_timing_constraints *	g_sdc = NULL

static FILE *	sdc

t_sdc_clock *	sdc_clocks = NULL

int	num_netlist_clocks = 0

char **	netlist_clocks

int	num_netlist_ios = 0

char **	netlist_ios

Macro Definition Documentation

#define SDC_TOKENS " \t\n{}[]" /* We can ignore braces. */

Typedef Documentation

typedef struct s_sdc_clock t_sdc_clock

typedef struct s_sdc_exclusive_group t_sdc_exclusive_group

Function Documentation

static void add_override_constraint	(	char **	from_list,
		int	num_from,
		char **	to_list,
		int	num_to,
		float	constraint,
		int	num_multicycles,
		boolean	domain_level_from,
		boolean	domain_level_to,
		boolean	make_copies
	)

static

Definition at line 1115 of file read_sdc.c.

                          {
     /* Add a special-case constraint to override the default, calculated timing constraint, 
     to one of four arrays depending on whether it's coming from/to a flip-flop or an entire clock domain. 
 
     If make_copies is true, we make a copy of from_list and to_list for this override constraint entry; 
     if false, we just set the override constraint entry to point to the existing list. The latter is 
     more efficient, but it's almost impossible to free multiple identical pointers without freeing
     the same thing twice and causing an error. */
 
     t_override_constraint ** constraint_array; 
     /* Because we are reallocating the array and possibly changing 
     its address, we need to modify it through a reference. */
 
     int num_constraints, i;
 
     if (domain_level_from) {
         if (domain_level_to) { /* Clock-to-clock constraint */
             constraint_array = &g_sdc->cc_constraints;
             num_constraints = ++g_sdc->num_cc_constraints;
         } else { /* Clock-to-flipflop constraint */
             constraint_array = &g_sdc->cf_constraints;
             num_constraints = ++g_sdc->num_cf_constraints;
         }
     } else {
         if (domain_level_to) { /* Flipflop-to-clock constraint */
             constraint_array = &g_sdc->fc_constraints;
             num_constraints = ++g_sdc->num_fc_constraints;
         } else { /* Flipflop-to-flipflop constraint */
             constraint_array = &g_sdc->ff_constraints;
             num_constraints = ++g_sdc->num_ff_constraints;
         }
     }
 
     *constraint_array = (t_override_constraint *) my_realloc(*constraint_array, num_constraints * sizeof(t_override_constraint));
     
     if (make_copies) {
         /* Copy from_list and to_list to constraint_array[num_constraints - 1].source_list and .sink_list. */
         (*constraint_array)[num_constraints - 1].source_list = (char **) my_malloc(num_from * sizeof(char *));
         (*constraint_array)[num_constraints - 1].sink_list = (char **) my_malloc(num_to * sizeof(char *));
         for (i = 0; i < num_from; i++) {
             (*constraint_array)[num_constraints - 1].source_list[i] = my_strdup(from_list[i]);
         }
         for (i = 0; i < num_to; i++) {
             (*constraint_array)[num_constraints - 1].sink_list[i] = my_strdup(to_list[i]);
         }
     } else {
         /* Just set constraint array to point to from_list and to_list. */
         (*constraint_array)[num_constraints - 1].source_list = from_list;
         (*constraint_array)[num_constraints - 1].sink_list = to_list;
     }
     (*constraint_array)[num_constraints - 1].num_source = num_from; 
     (*constraint_array)[num_constraints - 1].num_sink = num_to; 
     (*constraint_array)[num_constraints - 1].constraint = constraint;
     (*constraint_array)[num_constraints - 1].num_multicycles = num_multicycles;
     (*constraint_array)[num_constraints - 1].file_line_number = file_line_number; /* global var */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void alloc_and_load_netlist_clocks_and_ios ( void )

static

Definition at line 325 of file read_sdc.c.

                                                         {
 
     /* Count how many clocks and I/Os are in the netlist. 
     Store the names of each clock and each I/O in netlist_clocks and netlist_ios. */
 
     int iblock, i, clock_net;
     char * name;
     boolean found;
 
     for (iblock = 0; iblock < num_logical_blocks; iblock++) {
         if (logical_block[iblock].clock_net != OPEN) {
             clock_net = logical_block[iblock].clock_net;
             assert(clock_net != OPEN);
             name = logical_block[clock_net].name;
             /* Now that we've found a clock, let's see if we've counted it already */
             found = FALSE;
             for (i = 0; !found && i < num_netlist_clocks; i++) {
                 if (strcmp(netlist_clocks[i], name) == 0) {
                     found = TRUE;
                 }
             }
             if (!found) {
                 /* If we get here, the clock is new and so we dynamically grow the array netlist_clocks by one. */
                 netlist_clocks = (char **) my_realloc (netlist_clocks, ++num_netlist_clocks * sizeof(char *));
                 netlist_clocks[num_netlist_clocks - 1] = name;
             }
         } else if (logical_block[iblock].type == VPACK_INPAD || logical_block[iblock].type == VPACK_OUTPAD) {
             name = logical_block[iblock].name;
             /* Now that we've found an I/O, let's see if we've counted it already */
             found = FALSE;
             for (i = 0; !found && i < num_netlist_ios; i++) {
                 if (strcmp(netlist_ios[i], name) == 0) {
                     found = TRUE;
                 }
             }
             if (!found) {
                 /* If we get here, the I/O is new and so we dynamically grow the array netlist_ios by one. */
                 netlist_ios = (char **) my_realloc (netlist_ios, ++num_netlist_ios * sizeof(char *));
                 netlist_ios[num_netlist_ios - 1] = logical_block[iblock].type == VPACK_OUTPAD ? name + 4 : name; 
                 /* the + 4 removes the prefix "out:" automatically prepended to outputs */
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static float calculate_constraint	(	t_sdc_clock	source_domain,
		t_sdc_clock	sink_domain
	)

static

Definition at line 1174 of file read_sdc.c.

                                                                                       {
     /* Given information from the SDC file about the period and offset of two clocks, *
      * determine the implied setup-time constraint between them via edge counting.    */
 
     int source_period, sink_period, source_rising_edge, sink_rising_edge, lcm_period, num_source_edges, num_sink_edges, 
         * source_edges, * sink_edges, i, j, time, constraint_as_int;
     float constraint;
 
     /* If the source and sink domains have the same period and edges, the constraint is just the common clock period. */
     if (fabs(source_domain.period - sink_domain.period) < EPSILON && 
         fabs(source_domain.rising_edge - sink_domain.rising_edge) < EPSILON &&
         fabs(source_domain.falling_edge - sink_domain.falling_edge) < EPSILON) {
         return source_domain.period; /* or, equivalently, sink_domain.period */
     }
 
     /* If either period is 0, the constraint is 0. */
     if (source_domain.period < EPSILON || sink_domain.period < EPSILON) {
         return 0.;
     }
     
      /* Multiply periods and edges by 1000 and round down  *                  
       * to the nearest integer, to avoid messy decimals.   */
 
     source_period = static_cast<int>(source_domain.period * 1000);
     sink_period = static_cast<int>(sink_domain.period * 1000);
     source_rising_edge = static_cast<int>(source_domain.rising_edge * 1000);
     sink_rising_edge = static_cast<int>(sink_domain.rising_edge * 1000);    
 
     /* If we get here, we have to use edge counting.  Find the LCM of the two periods.         *
     * This determines how long it takes before the pattern of the two clocks starts repeating. */
     for (lcm_period = 1; lcm_period % source_period != 0 || lcm_period % sink_period != 0; lcm_period++)
         ;
 
     /* Create an array of positive edges for each clock over one LCM clock period. */
 
     num_source_edges = lcm_period/source_period + 1; 
     num_sink_edges = lcm_period/sink_period + 1;
 
     source_edges = (int *) my_malloc((num_source_edges + 1) * sizeof(int));
     sink_edges = (int *) my_malloc((num_sink_edges + 1) * sizeof(int));
     
     for (i = 0, time = source_rising_edge; i < num_source_edges + 1; i++) {
         source_edges[i] = time;
         time += source_period;
     }
 
     for (i = 0, time = sink_rising_edge; i < num_sink_edges + 1; i++) {
         sink_edges[i] = time;
         time += sink_period;
     }
 
     /* Compare every edge in source_edges with every edge in sink_edges.             *
      * The lowest STRICTLY POSITIVE difference between a sink edge and a source edge *
      * gives us the set-up time constraint.                                          */
 
     constraint_as_int = INT_MAX; /* constraint starts off at +ve infinity so that everything will be less than it */
 
     for (i = 0; i < num_source_edges + 1; i++) {
         for (j = 0; j < num_sink_edges + 1; j++) {
             if (sink_edges[j] > source_edges[i]) {
                 constraint_as_int = std::min(constraint_as_int, sink_edges[j] - source_edges[i]);
             }
         }
     }
 
     /* Divide by 1000 again and turn the constraint back into a float, and clean up memory. */
 
     constraint = constraint_as_int / 1000.;
 
     free(source_edges);
     free(sink_edges);
 
     return constraint;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void count_netlist_clocks_as_constrained_clocks ( void )

static

Definition at line 370 of file read_sdc.c.

                                                              {
     /* Counts how many clocks are in the netlist, and adds them to the array g_sdc->constrained_clocks. */
 
     int iblock, i, clock_net;
     char * name;
     boolean found;
 
     g_sdc->num_constrained_clocks = 0;
     
     for (iblock = 0; iblock < num_logical_blocks; iblock++) {
         if (logical_block[iblock].clock_net != OPEN) {
             clock_net = logical_block[iblock].clock_net;
             assert(clock_net != OPEN);
             name = logical_block[clock_net].name;
             /* Now that we've found a clock, let's see if we've counted it already */
             found = FALSE;
             for (i = 0; !found && i < g_sdc->num_constrained_clocks; i++) {
                 if (strcmp(g_sdc->constrained_clocks[i].name, name) == 0) {
                     found = TRUE;
                 }
             }
             if (!found) {
                 /* If we get here, the clock is new and so we dynamically grow the array g_sdc->constrained_clocks by one. */
                 g_sdc->constrained_clocks = (t_clock *) my_realloc (g_sdc->constrained_clocks, ++g_sdc->num_constrained_clocks * sizeof(t_clock));
                 g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].name = my_strdup(name);
                 g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].is_netlist_clock = TRUE;
                 /* Fanout will be filled out once the timing graph has been constructed. */
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void count_netlist_ios_as_constrained_ios	(	char *	clock_name,
		float	io_delay
	)

static

Definition at line 402 of file read_sdc.c.

                                                                                     {
     /* Count how many I/Os are in the netlist, adds them to the arrays g_sdc->constrained_inputs/
     g_sdc->constrained_outputs with an I/O delay of 0 and constrains them to clock clock_name. */
 
     int iblock, iinput, ioutput; 
     char * name;
     boolean found;
 
     for (iblock = 0; iblock < num_logical_blocks; iblock++) {
         if (logical_block[iblock].type == VPACK_INPAD) {
             name = logical_block[iblock].name;
             /* Now that we've found an I/O, let's see if we've counted it already */
             found = FALSE;
             for (iinput = 0; !found && iinput < g_sdc->num_constrained_inputs; iinput++) {
                 if (strcmp(g_sdc->constrained_inputs[iinput].name, name) == 0) {
                     found = TRUE;
                 }
             }
             if (!found) {
                 /* If we get here, the input is new and so we add it to g_sdc->constrained_inputs. */
                 g_sdc->constrained_inputs = (t_io *) my_realloc (g_sdc->constrained_inputs, ++g_sdc->num_constrained_inputs * sizeof(t_io));
                 g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].name = my_strdup(name); 
                 g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].clock_name = my_strdup(clock_name);
                 g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].delay = 0.;
             }
         } else if (logical_block[iblock].type == VPACK_OUTPAD) {
             name = logical_block[iblock].name;
             /* Now that we've found an I/O, let's see if we've counted it already */
             found = FALSE;
             for (ioutput = 0; !found && ioutput < g_sdc->num_constrained_outputs; ioutput++) {
                 if (strcmp(g_sdc->constrained_outputs[ioutput].name, name) == 0) {
                     found = TRUE;
                 }
             }
             if (!found) {
                 /* If we get here, the output is new and so we add it to g_sdc->constrained_outputs. */
                 g_sdc->constrained_outputs = (t_io *) my_realloc (g_sdc->constrained_outputs, ++g_sdc->num_constrained_outputs * sizeof(t_io));
                 g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].name = my_strdup(name + 4); 
                 /* the + 4 removes the prefix "out:" automatically prepended to outputs */
                 g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].clock_name = my_strdup(clock_name);
                 g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].delay = 0.;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int find_cc_constraint	(	char *	source_clock_domain,
		char *	sink_clock_domain
	)

static

Definition at line 1096 of file read_sdc.c.

                                                                                 {
     /* Given a pair of source and sink clock domains, find out if there's an override constraint between them.
     If there is, return the index in g_sdc->cc_constraints; if there is not, return -1. */
     int icc, isource, isink;
 
     for (icc = 0; icc < g_sdc->num_cc_constraints; icc++) {
         for (isource = 0; isource < g_sdc->cc_constraints[icc].num_source; isource++) {
             if (strcmp(g_sdc->cc_constraints[icc].source_list[isource], source_clock_name) == 0) {
                 for (isink = 0; isink < g_sdc->cc_constraints[icc].num_sink; isink++) {
                     if (strcmp(g_sdc->cc_constraints[icc].sink_list[isink], sink_clock_name) == 0) {
                         return icc;
                     }
                 }
             }
         }
     }
     return -1;
 }

Here is the caller graph for this function:

static int find_constrained_clock ( char * ptr )

static

Definition at line 1084 of file read_sdc.c.

                                               {
 /* Given a string ptr, find whether it's the name of a clock in the array g_sdc->constrained_clocks.  *
  * if it is, return the clock's index in g_sdc->constrained_clocks; if it's not, return -1. */
     int index;
     for (index = 0; index < g_sdc->num_constrained_clocks; index++) {
         if (strcmp(ptr, g_sdc->constrained_clocks[index].name) == 0) {
             return index;
         }
     }
     return -1;
 }

Here is the caller graph for this function:

static void free_clock_constraint	(	t_clock *&	clock_array,
		int	num_clocks
	)

static

Definition at line 1329 of file read_sdc.c.

                                                                           {
     int i;
 
     for (i = 0; i < num_clocks; i++) {
         free(clock_array[i].name);
     }
     free(clock_array);
     clock_array = NULL;
 }

Here is the caller graph for this function:

static void free_io_constraint	(	t_io *&	io_array,
		int	num_ios
	)

static

Definition at line 1318 of file read_sdc.c.

                                                               {
     int i;
 
     for (i = 0; i < num_ios; i++) {
         free(io_array[i].name);
         free(io_array[i].clock_name);
     }
     free(io_array);
     io_array = NULL;
 }

Here is the caller graph for this function:

void free_override_constraint	(	t_override_constraint *&	constraint_array,
		int	num_constraints
	)

Definition at line 1297 of file read_sdc.c.

                                                                                               {
     int i, j;
 
     if (!constraint_array) return;
 
     for (i = 0; i < num_constraints; i++) {
         for (j = 0; j < constraint_array[i].num_source; j++) {
             free(constraint_array[i].source_list[j]);
             constraint_array[i].source_list[j] = NULL;
         }
         for (j = 0; j < constraint_array[i].num_sink; j++) {
             free(constraint_array[i].sink_list[j]);
             constraint_array[i].sink_list[j] = NULL;
         }
         free(constraint_array[i].source_list);
         free(constraint_array[i].sink_list);
     }
     free(constraint_array);
     constraint_array = NULL;
 }

Here is the caller graph for this function:

void free_sdc_related_structs ( void )

Definition at line 1280 of file read_sdc.c.

                                     {
     if (!g_sdc) return;
 
     free_override_constraint(g_sdc->cc_constraints, g_sdc->num_cc_constraints); 
     /* Should already have been freed in process_constraints() */
 
     free_override_constraint(g_sdc->cf_constraints, g_sdc->num_cf_constraints);
     free_override_constraint(g_sdc->fc_constraints, g_sdc->num_fc_constraints);
     free_override_constraint(g_sdc->ff_constraints, g_sdc->num_ff_constraints);
     free_io_constraint(g_sdc->constrained_inputs, g_sdc->num_constrained_inputs);
     free_io_constraint(g_sdc->constrained_outputs, g_sdc->num_constrained_outputs);
     free_clock_constraint(g_sdc->constrained_clocks, g_sdc->num_constrained_clocks);
     free_matrix(g_sdc->domain_constraint, 0, g_sdc->num_constrained_clocks - 1, 0, sizeof(float));
     free(g_sdc);
     g_sdc = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean get_sdc_tok ( char * buf )

static

Definition at line 448 of file read_sdc.c.

                                        {
 /* Figures out which tokens are on this line and takes the appropriate actions. 
    Returns true if anything non-commented is found on this line. */
 
 #define SDC_TOKENS " \t\n{}[]" /* We can ignore braces. */
     
     char * ptr, ** from_list = NULL, ** to_list = NULL, * clock_name;
     float clock_period, rising_edge, falling_edge, max_delay;
     int iclock, iio, num_exclusive_groups = 0,  
         num_from = 0, num_to = 0, num_multicycles, i, j;
     t_sdc_exclusive_group * exclusive_groups = NULL;
     boolean found, domain_level_from = FALSE, domain_level_to = FALSE;
 
     /* my_strtok splits the string into tokens - little character arrays separated by the SDC_TOKENS 
     defined above. Throughout this code, ptr refers to the tokens we fetch, one at a time. The token 
     changes at each call of my_strtok. We call my_strtok with NULL as the first argument every time 
     AFTER the first, since this picks up tokenizing where we left off. We always wrap each call to 
     my_strtok with a check that ptr is non-null to avoid an exception from passing NULL into strcmp. */
 
 
     if ((ptr = my_strtok(buf, SDC_TOKENS, sdc, buf)) == NULL) {/* blank line */
         return FALSE;
     }
 
     if (strcmp(ptr, "create_clock") == 0) {
         /* Syntax: create_clock -period <float> [-waveform {rising_edge falling_edge}] <netlist clock list or regexes> 
                 or create_clock -period <float> [-waveform {rising_edge falling_edge}] -name <virtual clock name>*/
 
         /* make sure clock has -period specified */
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-period") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Create_clock must be directly followed by '-period'.\n", 
                     file_line_number);
             exit(1);
         }
                 
         /* Check if the token following -period is actually a number. */
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] A number must follow '-period'.\n", 
                     file_line_number);
             exit(1);
         }
         clock_period = (float) strtod(ptr, NULL);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Clock(s) not specified.\n",
                     file_line_number);
             exit(1);
         }
         if (strcmp(ptr, "-waveform") == 0) {
             
             /* Get the first float, which is the rising edge, and the second, which is the falling edge. */
             
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] First token following '-waveform' should be rising edge, but is not a number.\n",
                         file_line_number);
             }
             rising_edge = (float) strtod(ptr, NULL);
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Second token following '-waveform' should be falling edge, but is not a number.\n",
                         file_line_number);
                 exit(1);
             }
             falling_edge = (float) strtod(ptr, NULL);
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Clock(s) not specified.\n", 
                         file_line_number);
                 exit(1);
             } /* We need this extra call to my_strtok to advance the ptr to the right spot. */
 
         } else {
             /* The clock's rising edge is by default at 0, and the falling edge is at the half-period. */
             rising_edge = 0.;
             falling_edge = clock_period / 2.0;
         }
 
         if (strcmp(ptr, "-name") == 0) {
             /* For external virtual clocks only (used with I/O constraints).  
             Only one virtual clock can be specified per line, 
             so make sure there's only one token left on this line. */
 
             /* Get the virtual clock name */
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Virtual clock name not specified.\n", 
                         file_line_number);
                 exit(1);
             } /* We need this extra call to my_strtok to advance the ptr to the right spot. */
 
             /* We've found a new clock! */
 
             /* Store the clock's name, period and edges in the local array sdc_clocks. */
             sdc_clocks = (t_sdc_clock *) my_realloc(sdc_clocks, ++g_sdc->num_constrained_clocks * sizeof(t_sdc_clock));
             sdc_clocks[g_sdc->num_constrained_clocks - 1].name = ptr;
             sdc_clocks[g_sdc->num_constrained_clocks - 1].period = clock_period;
             sdc_clocks[g_sdc->num_constrained_clocks - 1].rising_edge = rising_edge; 
             sdc_clocks[g_sdc->num_constrained_clocks - 1].falling_edge = falling_edge; 
 
             /* Also store the clock's name, and the fact that it is not a netlist clock, in g_sdc->constrained_clocks. */
             g_sdc->constrained_clocks = (t_clock *) my_realloc (g_sdc->constrained_clocks, g_sdc->num_constrained_clocks * sizeof(t_clock));
             g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].name = my_strdup(ptr);
             g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].is_netlist_clock = FALSE;
             /* Fanout will be filled out once the timing graph has been constructed. */
 
             /* The next token should be NULL.  If so, return; if not, print an error message and exit. */
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] More than one virtual clock name is specified after '-name'.\n", 
                         file_line_number);
                 exit(1);
             }
 
         } else {
             /* Parse through to the end of the line.  All that should be left on this line are one or more
              * regular expressions denoting netlist clocks to be associated with this clock period.  An array sdc_clocks will
              * store the period and offset of each clock at the same index which that clock has in netlist_clocks.  Later,
              * after everything has been parsed, we take the information from this array to calculate the actual timing constraints
              * which these periods and offsets imply, and put them in the matrix g_sdc->domain_constraint. */
 
             do {
                 /* See if the regular expression stored in ptr is legal and matches at least one clock net. 
                 If it is not legal, it will fail during regex_match.  We check for a match using boolean found. */
                 found = FALSE;
                 for (iclock = 0; iclock < num_netlist_clocks; iclock++) {
                     if (regex_match(netlist_clocks[iclock], ptr)) {
                         /* We've found a new clock!  (Note that we can't store ptr as the clock's 
                         name since it could be a regex, unlike the virtual clock case).*/
                         found = TRUE;
 
                         /* Store the clock's name, period and edges in the local array sdc_clocks. */
                         sdc_clocks = (t_sdc_clock *) my_realloc(sdc_clocks, ++g_sdc->num_constrained_clocks * sizeof(t_sdc_clock));
                         sdc_clocks[g_sdc->num_constrained_clocks - 1].name = netlist_clocks[iclock];
                         sdc_clocks[g_sdc->num_constrained_clocks - 1].period = clock_period;
                         sdc_clocks[g_sdc->num_constrained_clocks - 1].rising_edge = rising_edge; 
                         sdc_clocks[g_sdc->num_constrained_clocks - 1].falling_edge = falling_edge;
 
                         /* Also store the clock's name, and the fact that it is a netlist clock, in g_sdc->constrained_clocks. */
                         g_sdc->constrained_clocks = (t_clock *) my_realloc (g_sdc->constrained_clocks, g_sdc->num_constrained_clocks * sizeof(t_clock));
                         g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].name = my_strdup(netlist_clocks[iclock]);
                         g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].is_netlist_clock = TRUE;
                         /* Fanout will be filled out once the timing graph has been constructed. */
                     }
                 }
 
                 if (!found) {
                     vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Clock name or regular expression does not correspond to any nets.\n", 
                             file_line_number);
                     vpr_printf(TIO_MESSAGE_ERROR, "If you'd like to create a virtual clock, use the '-name' keyword.\n");
                     exit(1);
                 }
             } while ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL); /* Advance to the next token (or the end of the line). */
         }
     
         /* Warn if the clock has non-50% duty cycle. */
         if (fabs(rising_edge - falling_edge) - clock_period/2.0 > EPSILON) {
             vpr_printf(TIO_MESSAGE_WARNING, "Clock %s does not have 50%% duty cycle.\n", 
                     sdc_clocks[g_sdc->num_constrained_clocks - 1].name);
         }
 
         return TRUE; 
 
     } else if (strcmp(ptr, "set_clock_groups") == 0) {
         /* Syntax: set_clock_groups -exclusive -group {<clock list or regexes>} -group {<clock list or regexes>} [-group {<clock list or regexes>} ...] */
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-exclusive") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_clock_groups must be directly followed by '-exclusive'.\n", 
                     file_line_number);
             exit(1);
         }
         
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-group") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_clock_groups '-exclusive' must be followed by lists of clock names or regular expressions each starting with the '-group' command.\n", 
                     file_line_number);
             exit(1);
         }
 
         /* Parse through to the end of the line. All that should be left on this line are a bunch of 
          -group commands, followed by groups of regexes. We need to ensure that paths are cut between 
          every clock matching a regex in one group and every clock matching a regex in any other group. */
 
         do {
             ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf);
             
             /* Create a new entry in exclusive groups */
             exclusive_groups = (t_sdc_exclusive_group *) my_realloc(
                 exclusive_groups, ++num_exclusive_groups * sizeof(t_sdc_exclusive_group));
             exclusive_groups[num_exclusive_groups - 1].clock_names = NULL;
             exclusive_groups[num_exclusive_groups - 1].num_clock_names = 0;
             do {
                 /* Check the regex ptr against each netlist clock and add it to the clock_names list if it matches. */
                 found = FALSE;
                 for (iclock = 0; iclock < num_netlist_clocks; iclock++) {
                     if (regex_match(netlist_clocks[iclock], ptr)) {
                         found = TRUE;
                         exclusive_groups[num_exclusive_groups - 1].clock_names = (char **) my_realloc(
                             exclusive_groups[num_exclusive_groups - 1].clock_names, ++exclusive_groups[num_exclusive_groups - 1].num_clock_names * sizeof(char *));
                         exclusive_groups[num_exclusive_groups - 1].clock_names
                             [exclusive_groups[num_exclusive_groups - 1].num_clock_names - 1] = 
                             my_strdup(netlist_clocks[iclock]);
                     }
                 }
                 if (!found) {
                     /* If no clocks matched, assume ptr is the name of a virtual clock and add it to the list.
                     (If it's not a virtual clock, we'll catch it later when we check all override constraints.) */
                     exclusive_groups[num_exclusive_groups - 1].clock_names = (char **) my_realloc(
                         exclusive_groups[num_exclusive_groups - 1].clock_names, ++exclusive_groups[num_exclusive_groups - 1].num_clock_names * sizeof(char *));
                     exclusive_groups[num_exclusive_groups - 1].clock_names
                         [exclusive_groups[num_exclusive_groups - 1].num_clock_names - 1] = 
                         my_strdup(ptr);
                 }
             } while ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL && strcmp(ptr, "-group") != 0);
         } while (ptr);
 
     if (num_exclusive_groups < 2) {
         vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] At least two '-group' commands required.", 
                 file_line_number); 
         exit(1);
     }
 
     /* Finally, create two DO_NOT_ANALYSE override constraints for each pair of entries
     to cut paths bidirectionally between pairs of clock lists in different groups. 
     Set make_copies to TRUE because we have to use the lists of names in multiple
     override constraints, and it's impossible to free them from multiple places at the
     end without a whole lot of trouble. */
 
         for (i = 0; i < num_exclusive_groups; i++) {
             for (j = 0; j < num_exclusive_groups; j++) {
                 if (i != j) {
                     add_override_constraint(exclusive_groups[i].clock_names, exclusive_groups[i].num_clock_names, 
                         exclusive_groups[j].clock_names, exclusive_groups[j].num_clock_names, DO_NOT_ANALYSE, 0, TRUE, TRUE, TRUE);
                 }
             }
         }
 
         /* Now that we've copied all the clock name lists
         (2 * num_exlusive_groups - 1) times, free the original lists. */
         for (i = 0; i < num_exclusive_groups; i++) {
             for (j = 0; j < exclusive_groups[i].num_clock_names; j++) {
                 free(exclusive_groups[i].clock_names[j]);
             }
             free(exclusive_groups[i].clock_names);
         }
         free (exclusive_groups);
 
         return TRUE;
 
     } else if (strcmp(ptr, "set_false_path") == 0) {
         /* Syntax: set_false_path -from <clock list or regexes> -to <clock list or regexes> */
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-from") != 0 || (ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_false_path must be directly followed by '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_from = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_false_path must be directly followed by '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to from_list until we hit the -to command. */
             from_list = (char **) my_realloc(from_list, ++num_from * sizeof(char *));
             from_list[num_from - 1] = my_strdup(ptr);
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) { 
                 /* We hit the end of the line before finding a -to. */
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_false_path requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
                 exit(1);
             }
         } while (strcmp(ptr, "-to") != 0);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_false_path requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                 file_line_number);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_to = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_false_path must be directly followed by '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to to_list until we hit the end of the line. */
             to_list = (char **) my_realloc(to_list, ++num_to * sizeof(char *));
             to_list[num_to - 1] = my_strdup(ptr);
         } while ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL);
 
         /* Create a constraint between each element in from_list and each element in to_list with value DO_NOT_ANALYSE. 
         Set make_copies to false since, as we only need to use from_list and to_list once, we can just have the
         override constraint entry point to those lists. */
         add_override_constraint(from_list, num_from, to_list, num_to, DO_NOT_ANALYSE, 0, domain_level_from, domain_level_to, FALSE);
         
         /* Finally, set from_list and to_list to NULL since they're both 
         being pointed to by the override constraint entry we just created. */
         from_list = NULL, to_list = NULL;
 
         return TRUE;
 
     } else if (strcmp(ptr, "set_max_delay") == 0) {
         /* Syntax: set_max_delay <delay> -from <clock list or regexes> -to <clock list or regexes> */
 
         /* Basically the same as set_false_path above, except we get a specific delay value for the constraint. */
 
         /* check if the token following set_max_delay is actually a number*/
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token following set_max_delay should be a delay value, but is not a number.\n", 
                     file_line_number);
             exit(1);
         }
         max_delay = (float) strtod(ptr, NULL);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-from") != 0 || (ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_max_delay requires '-from <clock/flip-flop_list>' after max_delay.\n", 
                     file_line_number);
             exit(1);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_from = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_max_delay requires '-from <clock/flip-flop_list>' after max_delay.\n", 
                         file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to from_list until we hit the -to command. */
             from_list = (char **) my_realloc(from_list, ++num_from * sizeof(char *));
             from_list[num_from - 1] = my_strdup(ptr);
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) { 
                 /* We hit the end of the line before finding a -to. */
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_max_delay requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                         file_line_number);
                 exit(1);
             }
         } while (strcmp(ptr, "-to") != 0);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_max_delay requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_to = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_max_delay requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                         file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to to_list until we hit the end of the line. */
             to_list = (char **) my_realloc(to_list, ++num_to * sizeof(char *));
             to_list[num_to - 1] = my_strdup(ptr);
         } while ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL);
 
         /* Create a constraint between each element in from_list and each element in to_list with value max_delay. */
         add_override_constraint(from_list, num_from, to_list, num_to, max_delay, 0, domain_level_from, domain_level_to, FALSE);
         
         /* Finally, set from_list and to_list to NULL since they're both 
         being pointed to by the override constraint entry we just created. */
         from_list = NULL, to_list = NULL;
 
         return TRUE;
 
     } else if (strcmp(ptr, "set_multicycle_path") == 0) {
         /* Syntax: set_multicycle_path -setup -from <clock list or regexes> -to <clock list or regexes> <num_multicycles> */
 
         /* Basically the same as set_false_path and set_max_delay above, except we have to calculate 
         the default value of the constraint (obtained via edge counting) first, and then set a  
         constraint equal to default constraint + (num_multicycles - 1) * period of sink clock domain. */
 
         /* check if the token following set_max_delay is actually a number*/
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-setup") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path must be directly followed by '-setup'.\n", 
                     file_line_number);
             exit(1);
         }
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-from") != 0 || (ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path requires '-from <clock/flip-flop_list>' after '-setup'.\n",
                     file_line_number);
             exit(1);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_from = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path '-setup' must be followed by '-from <clock/flip-flop_list>'.\n",
                         file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to from_list until we hit the -to command. */
             from_list = (char **) my_realloc(from_list, ++num_from * sizeof(char *));
             from_list[num_from - 1] = my_strdup(ptr);
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) { 
                 /* We hit the end of the line before finding a -to. */
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                         file_line_number);
                 exit(1);
             }
         } while (strcmp(ptr, "-to") != 0);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                     file_line_number);
         }
 
         if (strcmp(ptr, "get_clocks") == 0) {
             domain_level_to = TRUE;
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path requires '-to <clock/flip-flop_list>' after '-from <clock/flip-flop_list>'.\n", 
                         file_line_number);
                 exit(1);
             }
         }
 
         do {
             /* Keep adding clock names to to_list until we hit a number (i.e. num_multicycles). */
             to_list = (char **) my_realloc(to_list, ++num_to * sizeof(char *));
             to_list[num_to - 1] = my_strdup(ptr);
         } while (((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) != NULL) && !is_number(ptr));
 
         if (!ptr) {
             /* We hit the end of the line before finding a number. */
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_multicycle_path requires num_multicycles after '-to <clock/flip-flop_list>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         num_multicycles = (int) strtod(ptr, NULL);
 
         /* Create an override constraint between from and to. Unlike the previous two commands, set_multicycle_path requires 
         information about the periods and offsets of the clock domains which from and to, which we have to fill in at the end. */
         add_override_constraint(from_list, num_from, to_list, num_to, HUGE_NEGATIVE_FLOAT /* irrelevant - never used */,
             num_multicycles, domain_level_from, domain_level_to, FALSE);
         
         /* Finally, set from_list and to_list to NULL since they're both 
         being pointed to by the override constraint entry we just created. */
         from_list = NULL, to_list = NULL;
 
         return TRUE;
 
     } else if (strcmp(ptr, "set_input_delay") == 0) {
         /* Syntax: set_input_delay -clock <virtual or netlist clock> -max <max_delay> [get_ports {<I/O port list or regexes>}] */
         
         /* We want to assign virtual_clock to all input ports in port_list, and 
         set the input delay (from the external device to the FPGA) to max_delay. */
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-clock") != 0 || (ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_input_delay must be directly followed by '-clock <virtual or netlist clock name>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         if (num_netlist_clocks == 1 && strcmp(ptr, "*") == 0) {
             /* Allow the user to wildcard the clock name if there's only one clock (not standard SDC but very convenient). */
             clock_name = netlist_clocks[0];
         } else {
             /* We have no way of error-checking whether this is an actual virtual clock until we finish parsing. */
             clock_name = ptr;
         }
     
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-max") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_input_delay '-clock <virtual or netlist clock name>' must be directly followed by '-max <maximum_input_delay>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         /* check if the token following -max is actually a number*/
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token following '-max' should be a delay value, but is not a number.\n", 
                     file_line_number);
             exit(1);
         }
         max_delay = (float) strtod(ptr, NULL);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "get_ports") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_input_delay requires a [get_ports {...}] command following '-max <max_input_delay>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         /* Parse through to the end of the line.  Add each regular expression match we find to the list of 
             constrained inputs and give each entry the virtual clock name and max_delay we've just parsed.  
             We have no way of error-checking whether these tokens correspond to actual input ports until later. */
         
         for (;;) {
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) { /* end of line */
                 return TRUE; 
             }
 
             found = FALSE;
 
             for (iio = 0; iio < num_netlist_ios; iio++) {
                 /* See if the regular expression stored in ptr is legal and matches at least one input port. 
                 If it is not legal, it will fail during regex_match.  We check for a match using boolean found. */
                 if (regex_match(netlist_ios[iio], ptr)) {
                     /* We've found a new input! */
                     g_sdc->num_constrained_inputs++;
                     found = TRUE;
 
                     /* Fill in input information in the permanent array g_sdc->constrained_inputs. */
                     g_sdc->constrained_inputs = (t_io *) my_realloc (g_sdc->constrained_inputs, g_sdc->num_constrained_inputs * sizeof(t_io));
                     g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].name = my_strdup(netlist_ios[iio]);
                     g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].clock_name = my_strdup(clock_name);
                     g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].delay = max_delay;
                     g_sdc->constrained_inputs[g_sdc->num_constrained_inputs - 1].file_line_number = file_line_number; /* global var */
                 }
             }
 
             if (!found) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Output name or regular expression \"%s\" does not correspond to any nets.\n", 
                         file_line_number, ptr);
                 exit(1);
             }
         }
 
     } else if (strcmp(ptr, "set_output_delay") == 0) {
         /* Syntax: set_output_delay -clock <virtual or netlist clock> -max <max_delay> [get_ports {<I/O port list or regexes>}] */
         
         /* We want to assign virtual_clock to all output ports in port_list, and 
         set the output delay (from the external device to the FPGA) to max_delay. */
 
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-clock") != 0 || (ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_output_delay must be directly followed by '-clock <virtual or netlist clock name>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         if (num_netlist_clocks == 1 && strcmp(ptr, "*") == 0) {
             /* Allow the user to wildcard the clock name if there's only one clock (not standard SDC but very convenient). */
             clock_name = netlist_clocks[0];
         } else {
             /* We have no way of error-checking whether this is an actual virtual clock until we finish parsing. */
             clock_name = ptr;
         }
     
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "-max") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_output_delay -clock <virtual or netlist clock name> must be directly followed by '-max <maximum_output_delay>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         /* check if the token following -max is actually a number*/
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || !is_number(ptr)) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token following '-max' should be a delay value, but is not a number.\n", 
                     file_line_number);
             exit(1);
         }
         max_delay = (float) strtod(ptr, NULL);
 
         if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL || strcmp(ptr, "get_ports") != 0) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] set_output_delay requires a [get_ports {...}] command following '-max <max_output_delay>'.\n", 
                     file_line_number);
             exit(1);
         }
 
         /* Parse through to the end of the line.  Add each regular expression match we find to the list of 
             constrained outputs and give each entry the virtual clock name and max_delay we've just parsed.  
             We have no way of error-checking whether these tokens correspond to actual output ports until later. */
         
         for (;;) {
             if ((ptr = my_strtok(NULL, SDC_TOKENS, sdc, buf)) == NULL) { /* end of line */
                 return TRUE; 
             }
 
             found = FALSE;
 
             for (iio = 0; iio < num_netlist_ios; iio++) {
                 /* See if the regular expression stored in ptr is legal and matches at least one output port. 
                 If it is not legal, it will fail during regex_match.  We check for a match using boolean found. */
                 if (regex_match(netlist_ios[iio], ptr)) {
                     /* We've found a new output! */
                     g_sdc->num_constrained_outputs++;
                     found = TRUE;
 
                     /* Fill in output information in the permanent array g_sdc->constrained_outputs. */
                     g_sdc->constrained_outputs = (t_io *) my_realloc (g_sdc->constrained_outputs, g_sdc->num_constrained_outputs * sizeof(t_io));
                     g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].name = my_strdup(netlist_ios[iio]);
                     g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].clock_name = my_strdup(clock_name);
                     g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].delay = max_delay;
                     g_sdc->constrained_outputs[g_sdc->num_constrained_outputs - 1].file_line_number = file_line_number; /* global var */
                 }
             }
 
             if (!found) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Output name or regular expression \"%s\" does not correspond to any nets.\n", 
                         file_line_number, ptr);
                 exit(1);
             }
         }
 
     } else {
         vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Incorrect or unsupported syntax near start of line.\n", 
                 file_line_number);
         exit(1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean is_number ( char * ptr )

static

Definition at line 1064 of file read_sdc.c.

                                      {
 /* Checks if the character array ptr represents a valid floating-point number.  *
  * To return TRUE, all characters must be digits, although *
  * there can also be no more than one decimal point.       */
     int i, len, num_decimal_points = 0;
     len = strlen(ptr);
     for (i = 0; i < len; i++) {
         if ((ptr[i] < '0' || ptr[i] > '9')) {
             if (ptr[i] != '.') {
                 return FALSE;
             }
             num_decimal_points++;
             if (num_decimal_points > 1) {
                 return FALSE;
             }
         }
     }
     return TRUE;
 }

Here is the caller graph for this function:

void read_sdc ( t_timing_inf timing_inf )

Definition at line 115 of file read_sdc.c.

                                        {
 
     char buf[BUFSIZE];
     int source_clock_domain, sink_clock_domain, iinput, ioutput, icc, isource, isink;
     boolean found; 
     
     /* Make sure we haven't called this subroutine before. */
     assert(!g_sdc);
 
     /* Allocate container structure for SDC constraints. */
     g_sdc = (t_timing_constraints *) my_calloc(1, sizeof(t_timing_constraints));
     
     /* Reset file line number. */
     file_line_number = 0;
 
     /* If no SDC file is included or specified, or timing analysis is off,
     use default behaviour of cutting paths between domains and optimizing each clock separately */
 
     if (!timing_inf.timing_analysis_enabled) {
         vpr_printf(TIO_MESSAGE_INFO, "\n");
         vpr_printf(TIO_MESSAGE_INFO, "Timing analysis off; using default timing constraints.\n");
         use_default_timing_constraints();
         return;
     }
     
     if ((sdc = fopen(timing_inf.SDCFile, "r")) == NULL) {
         vpr_printf(TIO_MESSAGE_INFO, "\n");
         vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' blank or not found.\n", timing_inf.SDCFile);
         use_default_timing_constraints();
         return;
     }
     
     /* Now we have an SDC file. */
 
     /* Count how many clocks and I/Os are in the netlist. 
     Store the names of each clock and each I/O in netlist_clocks and netlist_ios. 
     The only purpose of these two lists is to compare clock names in the SDC file against them.
     As a result, they will be freed after the SDC file is parsed. */
     alloc_and_load_netlist_clocks_and_ios();
 
     /* Parse the file line-by-line. */
     found = FALSE;
     while (my_fgets(buf, BUFSIZE, sdc) != NULL) { 
         if (get_sdc_tok(buf)) {
             found = TRUE;
         }
     }
     if (!found) { /* blank file or only comments found */
         vpr_printf(TIO_MESSAGE_INFO, "\n");
         vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' blank or not found.\n", timing_inf.SDCFile);
         use_default_timing_constraints();
         free(netlist_clocks);
         free(netlist_ios);
         return;
     }
     
     fclose(sdc);
 
     /* Make sure that all virtual clocks referenced in g_sdc->constrained_inputs and g_sdc->constrained_outputs have been constrained. */
     for (iinput = 0; iinput < g_sdc->num_constrained_inputs; iinput++) {
         if ((find_constrained_clock(g_sdc->constrained_inputs[iinput].clock_name)) == -1) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Input %s is associated with an unconstrained clock %s.\n", 
                     g_sdc->constrained_inputs[iinput].file_line_number,
                     g_sdc->constrained_inputs[iinput].name, 
                     g_sdc->constrained_inputs[iinput].clock_name);
             exit(1);
         }
     }
 
     for (ioutput = 0; ioutput < g_sdc->num_constrained_outputs; ioutput++) {
         if ((find_constrained_clock(g_sdc->constrained_outputs[ioutput].clock_name)) == -1) {
             vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Output %s is associated with an unconstrained clock %s.\n", 
                     g_sdc->constrained_inputs[iinput].file_line_number,
                     g_sdc->constrained_outputs[ioutput].name, 
                     g_sdc->constrained_outputs[ioutput].clock_name);
             exit(1);
         }
     }
 
     /* Make sure that all clocks referenced in g_sdc->cc_constraints have been constrained. */
     for (icc = 0; icc < g_sdc->num_cc_constraints; icc++) {
         for (isource = 0; isource < g_sdc->cc_constraints[icc].num_source; isource++) {
             if ((find_constrained_clock(g_sdc->cc_constraints[icc].source_list[isource])) == -1) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token %s is not a constrained clock.\n", 
                         g_sdc->cc_constraints[icc].file_line_number,
                         g_sdc->cc_constraints[icc].source_list[isource]);
                 exit(1);
             }
         }
         for (isink = 0; isink < g_sdc->cc_constraints[icc].num_sink; isink++) {
             if ((find_constrained_clock(g_sdc->cc_constraints[icc].sink_list[isink])) == -1) {
                 vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token %s is not a constrained clock.\n",
                         g_sdc->cc_constraints[icc].file_line_number, 
                         g_sdc->cc_constraints[icc].sink_list[isink]);
                 exit(1);
             }
         }
     }
 
     /* Allocate matrix of timing constraints [0..g_sdc->num_constrained_clocks-1][0..g_sdc->num_constrained_clocks-1] and initialize to 0 */
     g_sdc->domain_constraint = (float **) alloc_matrix(0, g_sdc->num_constrained_clocks-1, 0, g_sdc->num_constrained_clocks-1, sizeof(float));
     
     /* Based on the information from sdc_clocks, calculate constraints for all paths except ones with an override constraint. */
     for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
         for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
             if ((icc = find_cc_constraint(g_sdc->constrained_clocks[source_clock_domain].name, g_sdc->constrained_clocks[sink_clock_domain].name)) != -1) {
                 if (g_sdc->cc_constraints[icc].num_multicycles == 0) {
                     /* There's a special constraint from set_false_path, set_clock_groups 
                     -exclusive or set_max_delay which overrides the default constraint. */
                     g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = g_sdc->cc_constraints[icc].constraint;
                 } else {
                     /* There's a special constraint from set_multicycle_path which overrides the default constraint. 
                     This constraint = default constraint (obtained via edge counting) + (num_multicycles - 1) * period of sink clock domain. */
                     g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = 
                         calculate_constraint(sdc_clocks[source_clock_domain], sdc_clocks[sink_clock_domain]) 
                         + (g_sdc->cc_constraints[icc].num_multicycles - 1) * sdc_clocks[sink_clock_domain].period;
                 }
             } else {
                 /* There's no special override constraint. */
                 /* Calculate the constraint between clock domains by finding the smallest positive 
                 difference between a posedge in the source domain and one in the sink domain. */
                 g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = 
                     calculate_constraint(sdc_clocks[source_clock_domain], sdc_clocks[sink_clock_domain]);
             }
         }
     }
 
     vpr_printf(TIO_MESSAGE_INFO, "\n");
     vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' parsed successfully.\n",
                  timing_inf.SDCFile ); 
     vpr_printf(TIO_MESSAGE_INFO, "%d clocks (including virtual clocks), %d inputs and %d outputs were constrained.\n", 
                  g_sdc->num_constrained_clocks, g_sdc->num_constrained_inputs, g_sdc->num_constrained_outputs);
     vpr_printf(TIO_MESSAGE_INFO, "\n");
     
     /* Since all the information we need is stored in g_sdc->domain_constraint, g_sdc->constrained_clocks, 
     and constrained_ios, free other data structures used in this routine */
     free(sdc_clocks);
     free(netlist_clocks);
     free(netlist_ios);
     return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean regex_match	(	char *	string,
		char *	pattern
	)

static

Definition at line 1249 of file read_sdc.c.

                                                                       {
     /* Given a string and a regular expression, return TRUE if there's a match, 
     FALSE if not. Print an error and exit if regular_expression is invalid. */
 
     const char * error;
     
     assert(string && regular_expression);
 
     /* The regex library reports a match if regular_expression is a substring of string
     AND not equal to string. This is not appropriate for our purposes. For example, 
     we'd get both "clock" and "clock2" matching the regular expression "clock".  
     We have to manually return that there's no match in this special case. */
     if (strstr(string, regular_expression) && strcmp(string, regular_expression) != 0)
         return FALSE;
 
     if (strcmp(regular_expression, "*") == 0)
         return TRUE; /* The regex library hangs if it is fed "*" as a regular expression. */
 
     error = slre_match((enum slre_option) 0, regular_expression, string, strlen(string));
 
     if (!error) 
         return TRUE;
     else if (strcmp(error, "No match") == 0) 
         return FALSE;
     else {
         vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Error matching regular expression \"%s\".\n", 
                 file_line_number, regular_expression);
         exit(1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void use_default_timing_constraints ( void )

static

Definition at line 257 of file read_sdc.c.

                                                  {
 
     int source_clock_domain, sink_clock_domain;
     
     /* Find all netlist clocks and add them as constrained clocks. */
     count_netlist_clocks_as_constrained_clocks();
 
     /* We'll use separate defaults for multi-clock and single-clock/combinational circuits. */
 
     if (g_sdc->num_constrained_clocks <= 1) {
         /* Create one constrained clock with period 0... */
         g_sdc->domain_constraint = (float **) alloc_matrix(0, 0, 0, 0, sizeof(float));
         g_sdc->domain_constraint[0][0] = 0.;
                 
         if (g_sdc->num_constrained_clocks == 0) {
             /* We need to create a virtual clock to constrain I/Os on. */
             g_sdc->num_constrained_clocks = 1;
             g_sdc->constrained_clocks = (t_clock *) my_malloc(sizeof(t_clock));
             g_sdc->constrained_clocks[0].name = my_strdup("virtual_io_clock");
             g_sdc->constrained_clocks[0].is_netlist_clock = FALSE;
 
             vpr_printf(TIO_MESSAGE_INFO, "\n");
             vpr_printf(TIO_MESSAGE_INFO, "Defaulting to: constrain all %d inputs and %d outputs on a virtual external clock.\n", 
                     g_sdc->num_constrained_inputs, g_sdc->num_constrained_outputs);
             vpr_printf(TIO_MESSAGE_INFO, "Optimize this virtual clock to run as fast as possible.\n");
         } else {
             vpr_printf(TIO_MESSAGE_INFO, "\n");
             vpr_printf(TIO_MESSAGE_INFO, "Defaulting to: constrain all %d inputs and %d outputs on the netlist clock.\n", 
                     g_sdc->num_constrained_inputs, g_sdc->num_constrained_outputs);
             vpr_printf(TIO_MESSAGE_INFO, "Optimize this clock to run as fast as possible.\n");
         }
         
         /* Constrain all I/Os on the single constrained clock (whether real or virtual), with I/O delay 0. */
         count_netlist_ios_as_constrained_ios(g_sdc->constrained_clocks[0].name, 0.);
 
     } else { /* Multiclock circuit */
 
         /* Constrain all I/Os on a separate virtual clock. Cut paths between all netlist
          clocks, but analyse all paths between the virtual I/O clock and netlist clocks
          and optimize all clocks to go as fast as possible. */
 
         g_sdc->constrained_clocks = (t_clock *) my_realloc (g_sdc->constrained_clocks, ++g_sdc->num_constrained_clocks * sizeof(t_clock));
         g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].name = my_strdup("virtual_io_clock");
         g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].is_netlist_clock = FALSE;
         count_netlist_ios_as_constrained_ios(g_sdc->constrained_clocks[g_sdc->num_constrained_clocks - 1].name, 0.);
 
         /* Allocate matrix of timing constraints [0..g_sdc->num_constrained_clocks-1][0..g_sdc->num_constrained_clocks-1] */
         g_sdc->domain_constraint = (float **) alloc_matrix(0, g_sdc->num_constrained_clocks-1, 0, g_sdc->num_constrained_clocks-1, sizeof(float));
 
         for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
             for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
                 if (source_clock_domain == sink_clock_domain || source_clock_domain == g_sdc->num_constrained_clocks - 1 
                     || sink_clock_domain == g_sdc->num_constrained_clocks - 1) {
                     g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = 0.;
                 } else {
                     g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = DO_NOT_ANALYSE;
                 }
             }
         }
         
         vpr_printf(TIO_MESSAGE_INFO, "\n");
         vpr_printf(TIO_MESSAGE_INFO, "Defaulting to: constrain all %d inputs and %d outputs on a virtual external clock;\n",
                 g_sdc->num_constrained_inputs, g_sdc->num_constrained_outputs);
         vpr_printf(TIO_MESSAGE_INFO, "\tcut paths between netlist clock domains; and\n");
         vpr_printf(TIO_MESSAGE_INFO, "\toptimize all clocks to run as fast as possible.\n");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

t_timing_constraints* g_sdc = NULL

Definition at line 65 of file read_sdc.c.

char** netlist_clocks

Definition at line 90 of file read_sdc.c.

char** netlist_ios

Definition at line 93 of file read_sdc.c.

int num_netlist_clocks = 0

Definition at line 89 of file read_sdc.c.

int num_netlist_ios = 0

Definition at line 92 of file read_sdc.c.

FILE* sdc

static

Definition at line 86 of file read_sdc.c.

t_sdc_clock* sdc_clocks = NULL

Definition at line 87 of file read_sdc.c.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation