1 | #include "debugInt.h" |
---|
2 | /**Function******************************************************************** |
---|
3 | |
---|
4 | Synopsis [create New node] |
---|
5 | |
---|
6 | Description [Create new primary input in the current network at a given |
---|
7 | output node. Return the variable created] |
---|
8 | |
---|
9 | SideEffects [Modify the network] |
---|
10 | |
---|
11 | SeeAlso [] |
---|
12 | |
---|
13 | ******************************************************************************/ |
---|
14 | Ntk_Node_t * Dbg_CreateNewNode(Ntk_Network_t * ntk,Ntk_Node_t* |
---|
15 | node, char * varName ) |
---|
16 | { |
---|
17 | array_t * fanin = array_dup(Ntk_NodeReadFanins(node)); |
---|
18 | array_t * fanout = array_alloc(Ntk_Node_t*,0); |
---|
19 | char * nodeName = util_strsav(Ntk_NodeReadName(node)); |
---|
20 | //Create var Name |
---|
21 | char * newVarName = (char *) malloc(strlen(nodeName) + strlen(varName) +1); |
---|
22 | sprintf(newVarName,"%s_%s",nodeName,varName); |
---|
23 | Var_Variable_t * var = Var_VariableAlloc(NIL(Hrc_Node_t),newVarName); |
---|
24 | //Create new Node |
---|
25 | Ntk_Node_t * newNode = Ntk_NodeCreateInNetwork(ntk, newVarName,var); |
---|
26 | Ntk_NodeDeclareAsPrimaryInput(newNode); |
---|
27 | //Add in the fanin of the node |
---|
28 | array_insert_last(Ntk_Node_t*,fanin,newNode); |
---|
29 | Ntk_NodeSetFanins(node,fanin); |
---|
30 | //Add Fanout to the newNode |
---|
31 | array_insert_last(Ntk_Node_t*,fanout,node); |
---|
32 | Ntk_NodeSetFanouts(newNode,fanout); |
---|
33 | free(newVarName); |
---|
34 | |
---|
35 | return newNode; |
---|
36 | |
---|
37 | } |
---|
38 | /**Function******************************************************************** |
---|
39 | |
---|
40 | Synopsis [Add abnormal predicates to the network] |
---|
41 | |
---|
42 | Description [Given a network after flatten the hierarchy, |
---|
43 | change the table of each combinatorial node |
---|
44 | with a new table including the abnormal predicate. |
---|
45 | For a combinatorial node n is tranformed into (abn_n)?i_n:n |
---|
46 | If the abnormal predicate is activ then n is replaced by a free input] |
---|
47 | |
---|
48 | SideEffects [fill the abnormal structure] |
---|
49 | |
---|
50 | SeeAlso [] |
---|
51 | |
---|
52 | ******************************************************************************/ |
---|
53 | |
---|
54 | void Dbg_AddAbnormalPredicatetoNetwork(Dbg_Abnormal_t* abnormal ) /*abnormal struct*/ |
---|
55 | { |
---|
56 | |
---|
57 | Ntk_Network_t * ntk = abnormal->network; |
---|
58 | lsGen gen; |
---|
59 | Ntk_Node_t* node; |
---|
60 | Ntk_NetworkForEachNode(ntk,gen,node){ |
---|
61 | //For each combinatorial node |
---|
62 | if(Ntk_NodeTestIsCombinational(node)){ |
---|
63 | if(Ntk_NodeReadNumFanins(node) > 1 && Ntk_NodeReadNumFanouts(node)> 0) |
---|
64 | { |
---|
65 | char * nodeName = util_strsav(Ntk_NodeReadName(node)); |
---|
66 | printf("%s \n", nodeName); |
---|
67 | |
---|
68 | Tbl_Table_t *table = Ntk_NodeReadTable(node); |
---|
69 | (void) fprintf(vis_stdout, "** old table\n"); |
---|
70 | Tbl_TableWriteBlifMvToFile(table,2,vis_stdout); |
---|
71 | // Build new variables abnormal and input |
---|
72 | Ntk_Node_t * abnNode = Dbg_CreateNewNode(ntk,node,"abn"); |
---|
73 | Ntk_Node_t * iNode = Dbg_CreateNewNode(ntk,node,"i"); |
---|
74 | Dbg_AddFreeInput(abnormal,iNode); |
---|
75 | Dbg_AddAbnormalPredicate(abnormal,abnNode); |
---|
76 | Var_Variable_t * abn = Ntk_NodeReadVariable(abnNode); |
---|
77 | Var_Variable_t * i = Ntk_NodeReadVariable(iNode); |
---|
78 | //Add in the table |
---|
79 | Tbl_TableAddColumn(table,abn,0); |
---|
80 | int abnIndex = Tbl_TableReadVarIndex(table, abn, 0); |
---|
81 | Tbl_TableAddColumn(table,i,0); |
---|
82 | int iIndex = Tbl_TableReadVarIndex(table, i, 0); |
---|
83 | |
---|
84 | //For each row already there in the table |
---|
85 | int rowNum; |
---|
86 | for(rowNum = 0; rowNum < Tbl_TableReadNumRows(table);rowNum++){ |
---|
87 | Tbl_Entry_t *abnEntry = Tbl_EntryAlloc(Tbl_EntryNormal_c); |
---|
88 | Tbl_EntrySetValue(abnEntry,0,0); |
---|
89 | Tbl_TableSetEntry(table, abnEntry, rowNum, abnIndex, 0); |
---|
90 | Tbl_Entry_t *iEntry = Tbl_EntryAlloc(Tbl_EntryNormal_c); |
---|
91 | Tbl_EntrySetValue(iEntry,0,1); |
---|
92 | Tbl_TableSetEntry(table, iEntry, rowNum, iIndex, 0); |
---|
93 | } |
---|
94 | //the new row |
---|
95 | int r = Tbl_TableAddRow(table); |
---|
96 | |
---|
97 | int colNum; |
---|
98 | for (colNum = 0; colNum < Tbl_TableReadNumInputs(table); colNum++) { |
---|
99 | Tbl_Entry_t * entry = Tbl_EntryAlloc(Tbl_EntryNormal_c); |
---|
100 | if(colNum == abnIndex || colNum == iIndex) |
---|
101 | Tbl_EntrySetValue(entry,1,1); |
---|
102 | else |
---|
103 | Tbl_EntrySetValue(entry,0,1); |
---|
104 | Tbl_TableSetEntry(table, entry, r, colNum, 0); |
---|
105 | } |
---|
106 | for (colNum = 0; colNum < Tbl_TableReadNumOutputs(table); colNum++){ |
---|
107 | Tbl_Entry_t * entry = Tbl_EntryAlloc(Tbl_EntryNormal_c); |
---|
108 | Tbl_EntrySetValue(entry,1,1); |
---|
109 | Tbl_TableSetEntry(table, entry, r, colNum, 1); |
---|
110 | } |
---|
111 | printf("---------------\n"); |
---|
112 | Tbl_TableWriteBlifMvToFile(table,0,vis_stdout); |
---|
113 | } |
---|
114 | } |
---|
115 | } |
---|
116 | } |
---|
117 | /**Function******************************************************************** |
---|
118 | |
---|
119 | Synopsis [Allocate a new abnormal structure] |
---|
120 | |
---|
121 | Description [The structure contains the network with abnormal predicate, |
---|
122 | and two sets of Ntk_Node_t for the abnormal and the free inputs] |
---|
123 | |
---|
124 | SideEffects [Allocate the abnormal structure] |
---|
125 | |
---|
126 | SeeAlso [] |
---|
127 | |
---|
128 | ******************************************************************************/ |
---|
129 | |
---|
130 | Dbg_Abnormal_t * Dbg_DebugAbnormalAlloc(Ntk_Network_t * network) |
---|
131 | { |
---|
132 | Dbg_Abnormal_t * abn = ALLOC(Dbg_Abnormal_t, 1); |
---|
133 | |
---|
134 | abn->network = network; |
---|
135 | abn->abnormal = array_alloc(Ntk_Node_t*,0); |
---|
136 | abn->freeInputs = array_alloc(Ntk_Node_t*,0); |
---|
137 | abn->verbose = 0; |
---|
138 | return abn; |
---|
139 | } |
---|
140 | |
---|
141 | /**Function******************************************************************** |
---|
142 | |
---|
143 | Synopsis [Deallocate a new abnormal structure] |
---|
144 | |
---|
145 | Description [Free the arrays not the network] |
---|
146 | |
---|
147 | SideEffects [free the abnormal structure] |
---|
148 | |
---|
149 | SeeAlso [] |
---|
150 | |
---|
151 | ******************************************************************************/ |
---|
152 | |
---|
153 | void Dbg_DebugAbnormalFree(Dbg_Abnormal_t * abn) |
---|
154 | { |
---|
155 | array_free(abn->abnormal); |
---|
156 | array_free(abn->freeInputs); |
---|
157 | FREE(abn); |
---|
158 | } |
---|
159 | |
---|
160 | |
---|
161 | /**Function******************************************************************** |
---|
162 | |
---|
163 | Synopsis [Add abnormal predicate] |
---|
164 | |
---|
165 | Description [add a node to the predicates array, it should not be already |
---|
166 | present by construction of abnormal predicate] |
---|
167 | |
---|
168 | SideEffects [] |
---|
169 | |
---|
170 | SeeAlso [] |
---|
171 | |
---|
172 | ******************************************************************************/ |
---|
173 | |
---|
174 | void Dbg_AddAbnormalPredicate(Dbg_Abnormal_t * abn, Ntk_Node_t* abnNode) |
---|
175 | { |
---|
176 | assert(abnNode != NIL(Ntk_Node_t*)); |
---|
177 | array_insert_last(Ntk_Node_t*,abn->abnormal, abnNode); |
---|
178 | } |
---|
179 | /**Function******************************************************************** |
---|
180 | |
---|
181 | Synopsis [Add free inputs] |
---|
182 | |
---|
183 | Description [add a node to the free inputs, it should not be already |
---|
184 | present by construction of abnormal predicate] |
---|
185 | |
---|
186 | SideEffects [] |
---|
187 | |
---|
188 | SeeAlso [] |
---|
189 | |
---|
190 | ******************************************************************************/ |
---|
191 | void Dbg_AddFreeInput(Dbg_Abnormal_t * abn, Ntk_Node_t* fNode) |
---|
192 | { |
---|
193 | assert(fNode != NIL(Ntk_Node_t*)); |
---|
194 | array_insert_last(Ntk_Node_t*,abn->freeInputs, fNode); |
---|
195 | } |
---|
196 | |
---|
197 | /**Function******************************************************************** |
---|
198 | |
---|
199 | Synopsis [returns a free inputs] |
---|
200 | |
---|
201 | Description [returns the array of freeinputs] |
---|
202 | |
---|
203 | SideEffects [] |
---|
204 | |
---|
205 | SeeAlso [Dbg_ReadAbn] |
---|
206 | |
---|
207 | ******************************************************************************/ |
---|
208 | array_t* Dbg_ReadFreeInputs(Dbg_Abnormal_t *abnormal) |
---|
209 | { |
---|
210 | assert(abnormal != NIL(Dbg_Abnormal_t)); |
---|
211 | return abnormal->freeInputs; |
---|
212 | } |
---|
213 | /**Function******************************************************************** |
---|
214 | |
---|
215 | Synopsis [returns a abnormal predicates] |
---|
216 | |
---|
217 | Description [returns the array of abnormal predicates] |
---|
218 | |
---|
219 | SideEffects [] |
---|
220 | |
---|
221 | SeeAlso [Dbg_ReadFreeInputs] |
---|
222 | |
---|
223 | ******************************************************************************/ |
---|
224 | array_t* Dbg_ReadAbn(Dbg_Abnormal_t *abnormal) |
---|
225 | { |
---|
226 | assert(abnormal != NIL(Dbg_Abnormal_t)); |
---|
227 | return abnormal->abnormal; |
---|
228 | } |
---|
229 | |
---|