ccv_nnc_symbolic_graph

Bug Summary

File:	nnc/ccv_nnc_symbolic_graph_io.c
Warning:	line 670, column 31 Passed-by-value struct argument contains uninitialized data (e.g., field: 'reserved')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ccv_nnc_symbolic_graph_io.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +sse2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -fcoverage-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -resource-dir /usr/local/lib/clang/19 -I ../ -I /usr/local/cuda/include -D HAVE_CBLAS -D HAVE_LIBPNG -D HAVE_LIBJPEG -D HAVE_FFTW3 -D HAVE_PTHREAD -D HAVE_LIBLINEAR -D HAVE_TESSERACT -D HAVE_AVCODEC -D HAVE_AVFORMAT -D HAVE_AVUTIL -D HAVE_SWSCALE -D HAVE_SSE2 -D HAVE_GSL -D HAVE_CUDA -D HAVE_CUDNN -D HAVE_NCCL -D USE_SYSTEM_CUB -I /usr/local/include -internal-isystem /usr/local/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/liu/actions-runner/_work/ccv/ccv/_analyze/2025-12-04-111618-185202-1 -x c ccv_nnc_symbolic_graph_io.c
1#include "ccv_nnc.h"
2#include "ccv_nnc_easy.h"
3#include "ccv_nnc_internal.h"
4#include "ccv_internal.h"
5#include "_ccv_nnc_symbolic_graph.h"
6#include "3rdparty/sqlite3/sqlite3.h"
7#ifdef HAVE_CUDA1
8#include "gpu/ccv_nnc_compat.h"
9#endif
10 
11// MARK - Level-3 API
12 
13#ifdef NDEBUG
14#define SQLITE_ENFORCE(stmt)((void) sizeof ((stmt) ? 1 : 0), __extension__ ({ if (stmt) ;
 else __assert_fail ("stmt", "ccv_nnc_symbolic_graph_io.c", 14
, __extension__ __PRETTY_FUNCTION__); })) (void)(stmt)
15#else
16#define SQLITE_ENFORCEassert assert
17#endif
18 
19static int _ccv_nnc_symbolic_graph_index_in_repo(const ccv_nnc_symbolic_graph_t* const graph, const ccv_array_t* const repo)
20{
21	if (!graph)
22		return -1;
23	int i;
24	for (i = 0; i < repo->rnum; i++)
25		if (*(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, i)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(i))) == graph)
26			return i;
27	return -1;
28}
29 
30static void _ccv_nnc_symbolic_graph_write(const ccv_nnc_symbolic_graph_t* const graph, const ccv_array_t* const repo, const int graph_idx, sqlite3_stmt* const tensor_symbol_insert_stmt, sqlite3_stmt* const exec_symbol_insert_stmt, sqlite3_stmt* const graph_insert_stmt, ccv_array_t* const ws)
31{
32	int i;
33	for (i = 0; i < graph->tensor_symbol_info->rnum; i++)
34	{
35		const ccv_nnc_tensor_symbol_info_t* const symbol_info = (ccv_nnc_tensor_symbol_info_t*)ccv_array_get(graph->tensor_symbol_info, i)((void*)(((char*)((graph->tensor_symbol_info)->data)) +
 (size_t)(graph->tensor_symbol_info)->rsize * (size_t)(
i)));
36		sqlite3_bind_int(tensor_symbol_insert_stmt, 1, i);
37		sqlite3_bind_int(tensor_symbol_insert_stmt, 2, graph_idx);
38		sqlite3_bind_int(tensor_symbol_insert_stmt, 3, symbol_info->assign_ref);
39		sqlite3_bind_int(tensor_symbol_insert_stmt, 4, symbol_info->r_assign_ref);
40		sqlite3_bind_int(tensor_symbol_insert_stmt, 5, symbol_info->bypass_ref);
41		sqlite3_bind_int(tensor_symbol_insert_stmt, 6, symbol_info->r_bypass_ref);
42		sqlite3_bind_int(tensor_symbol_insert_stmt, 7, symbol_info->p_ref);
43		sqlite3_bind_int(tensor_symbol_insert_stmt, 8, symbol_info->alias_ref);
44		sqlite3_bind_int(tensor_symbol_insert_stmt, 9, symbol_info->pair_ref);
45		sqlite3_bind_int(tensor_symbol_insert_stmt, 10, symbol_info->flags);
46		sqlite3_bind_blob(tensor_symbol_insert_stmt, 11, symbol_info->ofs, sizeof(symbol_info->ofs), 0);
47		sqlite3_bind_blob(tensor_symbol_insert_stmt, 12, symbol_info->stride, sizeof(symbol_info->stride), 0);
48		if (symbol_info->s_ref)
49			sqlite3_bind_blob(tensor_symbol_insert_stmt, 13, ccv_array_get(symbol_info->s_ref, 0)((void*)(((char*)((symbol_info->s_ref)->data)) + (size_t
)(symbol_info->s_ref)->rsize * (size_t)(0))), sizeof(int) * symbol_info->s_ref->rnum, 0);
50		else
51			sqlite3_bind_null(tensor_symbol_insert_stmt, 13);
52		if (symbol_info->name)
53			sqlite3_bind_text(tensor_symbol_insert_stmt, 14, symbol_info->name, -1, 0);
54		else
55			sqlite3_bind_null(tensor_symbol_insert_stmt, 14);
56		sqlite3_bind_int(tensor_symbol_insert_stmt, 15, symbol_info->info.type);
57		sqlite3_bind_int(tensor_symbol_insert_stmt, 16, symbol_info->info.format);
58		sqlite3_bind_int(tensor_symbol_insert_stmt, 17, symbol_info->info.datatype);
59		sqlite3_bind_blob(tensor_symbol_insert_stmt, 18, symbol_info->info.dim, sizeof(symbol_info->info.dim), 0);
60		SQLITE_ENFORCE(SQLITE_DONE == sqlite3_step(tensor_symbol_insert_stmt))((void) sizeof ((101 == sqlite3_step(tensor_symbol_insert_stmt
)) ? 1 : 0), __extension__ ({ if (101 == sqlite3_step(tensor_symbol_insert_stmt
)) ; else __assert_fail ("SQLITE_DONE == sqlite3_step(tensor_symbol_insert_stmt)"
, "ccv_nnc_symbolic_graph_io.c", 60, __extension__ __PRETTY_FUNCTION__
); }));
61		sqlite3_reset(tensor_symbol_insert_stmt);
62		sqlite3_clear_bindings(tensor_symbol_insert_stmt);
63	}
64	for (i = 0; i < graph->exec_symbol_info->rnum; i++)
65	{
66		const ccv_nnc_graph_exec_symbol_info_t* const symbol_info = (ccv_nnc_graph_exec_symbol_info_t*)ccv_array_get(graph->exec_symbol_info, i)((void*)(((char*)((graph->exec_symbol_info)->data)) + (
size_t)(graph->exec_symbol_info)->rsize * (size_t)(i)));
67		sqlite3_bind_int(exec_symbol_insert_stmt, 1, i);
68		sqlite3_bind_int(exec_symbol_insert_stmt, 2, graph_idx);
69		sqlite3_bind_int(exec_symbol_insert_stmt, 3, symbol_info->input_size);
70		sqlite3_bind_int(exec_symbol_insert_stmt, 4, symbol_info->output_size);
71		sqlite3_bind_int(exec_symbol_insert_stmt, 5, symbol_info->graph_ref_size);
72		sqlite3_bind_int(exec_symbol_insert_stmt, 6, symbol_info->flags);
73		sqlite3_bind_int(exec_symbol_insert_stmt, 7, symbol_info->pair_ref);
74		if (symbol_info->input_size)
75			sqlite3_bind_blob(exec_symbol_insert_stmt, 8, symbol_info->inputs, sizeof(int) * symbol_info->input_size, 0);
76		if (symbol_info->output_size)
77			sqlite3_bind_blob(exec_symbol_insert_stmt, 9, symbol_info->outputs, sizeof(int) * symbol_info->output_size, 0);
78		if (symbol_info->outgoings && symbol_info->outgoings->rnum)
79			sqlite3_bind_blob(exec_symbol_insert_stmt, 10, ccv_array_get(symbol_info->outgoings, 0)((void*)(((char*)((symbol_info->outgoings)->data)) + (size_t
)(symbol_info->outgoings)->rsize * (size_t)(0))), sizeof(int) * symbol_info->outgoings->rnum, 0);
80		if (symbol_info->name)
81			sqlite3_bind_text(exec_symbol_insert_stmt, 11, symbol_info->name, -1, 0);
82		sqlite3_bind_int(exec_symbol_insert_stmt, 12, symbol_info->cmd.cmd);
83		sqlite3_bind_int(exec_symbol_insert_stmt, 13, symbol_info->cmd.backend);
84		sqlite3_bind_int(exec_symbol_insert_stmt, 14, symbol_info->cmd.algorithm);
85		sqlite3_bind_blob(exec_symbol_insert_stmt, 15, &symbol_info->cmd.info, sizeof(symbol_info->cmd.info), 0);
86		sqlite3_bind_blob(exec_symbol_insert_stmt, 16, &symbol_info->hint, sizeof(symbol_info->hint), 0);
87		if (symbol_info->graph_ref_size)
88			sqlite3_bind_blob(exec_symbol_insert_stmt, 17, CCV_NNC_GRAPH_REF(symbol_info)((symbol_info)->_heap_graph_ref ? (symbol_info)->_heap_graph_ref
 : (symbol_info)->_inline_graph_ref), sizeof(int) * symbol_info->graph_ref_size, 0);
89		if (symbol_info->flags & CCV_NNC_GRAPH_EXEC_CASE_OF)
90		{
91			sqlite3_bind_int(exec_symbol_insert_stmt, 18, 0);
92			sqlite3_bind_int(exec_symbol_insert_stmt, 19, symbol_info->case_of.flags);
93			sqlite3_bind_int(exec_symbol_insert_stmt, 20, symbol_info->case_of.argument.offset);
94			sqlite3_bind_int(exec_symbol_insert_stmt, 21, symbol_info->case_of.argument.size);
95		}
96		if (symbol_info->flags & CCV_NNC_GRAPH_EXEC_P_WHILE)
97		{
98			sqlite3_bind_int(exec_symbol_insert_stmt, 22, 0);
99			sqlite3_bind_int(exec_symbol_insert_stmt, 23, symbol_info->p_while.input_size);
100			if (symbol_info->p_while.input_size)
101				sqlite3_bind_blob(exec_symbol_insert_stmt, 24, symbol_info->p_while.inputs, sizeof(int) * symbol_info->p_while.input_size, 0);
102		}
103		SQLITE_ENFORCE(SQLITE_DONE == sqlite3_step(exec_symbol_insert_stmt))((void) sizeof ((101 == sqlite3_step(exec_symbol_insert_stmt)
) ? 1 : 0), __extension__ ({ if (101 == sqlite3_step(exec_symbol_insert_stmt
)) ; else __assert_fail ("SQLITE_DONE == sqlite3_step(exec_symbol_insert_stmt)"
, "ccv_nnc_symbolic_graph_io.c", 103, __extension__ __PRETTY_FUNCTION__
); }));
104		sqlite3_reset(exec_symbol_insert_stmt);
105		sqlite3_clear_bindings(exec_symbol_insert_stmt);
106	}
107	ccv_array_clear(ws);
108	sqlite3_bind_int(graph_insert_stmt, 1, graph_idx);
109	sqlite3_bind_int(graph_insert_stmt, 2, graph->tensor_symbol_info->rnum);
110	sqlite3_bind_int(graph_insert_stmt, 3, graph->exec_symbol_info->rnum);
111	if (graph->sources && graph->sources->rnum)
112		for (i = 0; i < graph->sources->rnum; i++)
113			ccv_array_push(ws, &((ccv_nnc_graph_exec_symbol_t*)ccv_array_get(graph->sources, i)((void*)(((char*)((graph->sources)->data)) + (size_t)(graph
->sources)->rsize * (size_t)(i))))->d);
114	if (graph->destinations && graph->destinations->rnum)
115		for (i = 0; i < graph->destinations->rnum; i++)
116			ccv_array_push(ws, &((ccv_nnc_graph_exec_symbol_t*)ccv_array_get(graph->destinations, i)((void*)(((char*)((graph->destinations)->data)) + (size_t
)(graph->destinations)->rsize * (size_t)(i))))->d);
117	if (graph->sub_graphs && graph->sub_graphs->rnum)
118		for (i = 0; i < graph->sub_graphs->rnum; i++)
119		{
120			const int sub_graph_idx = _ccv_nnc_symbolic_graph_index_in_repo(*(ccv_nnc_symbolic_graph_t**)ccv_array_get(graph->sub_graphs, i)((void*)(((char*)((graph->sub_graphs)->data)) + (size_t
)(graph->sub_graphs)->rsize * (size_t)(i))), repo);
121			ccv_array_push(ws, &sub_graph_idx);
122		}
123	if (graph->breakpoint_size && graph->breakpoints)
124		for (i = 0; i < graph->breakpoint_size; i++)
125			ccv_array_push(ws, &graph->breakpoints[i].d);
126	const int* pos = (int*)ccv_array_get(ws, 0)((void*)(((char*)((ws)->data)) + (size_t)(ws)->rsize * (
size_t)(0)));
127	if (graph->sources && graph->sources->rnum)
128	{
129		sqlite3_bind_blob(graph_insert_stmt, 4, pos, sizeof(int) * graph->sources->rnum, 0);
130		pos += graph->sources->rnum;
131	}
132	if (graph->destinations && graph->destinations->rnum)
133	{
134		sqlite3_bind_blob(graph_insert_stmt, 5, pos, sizeof(int) * graph->destinations->rnum, 0);
135		pos += graph->destinations->rnum;
136	}
137	if (graph->sub_graphs && graph->sub_graphs->rnum)
138	{
139		sqlite3_bind_blob(graph_insert_stmt, 6, pos, sizeof(int) * graph->sub_graphs->rnum, 0);
140		pos += graph->sub_graphs->rnum;
141	}
142	sqlite3_bind_int(graph_insert_stmt, 7, _ccv_nnc_symbolic_graph_index_in_repo(graph->pair, repo));
143	sqlite3_bind_int(graph_insert_stmt, 8, _ccv_nnc_symbolic_graph_index_in_repo(graph->p, repo));
144	sqlite3_bind_int(graph_insert_stmt, 9, graph->p_idx);
145	sqlite3_bind_int(graph_insert_stmt, 10, graph->exec_idx);
146	sqlite3_bind_int(graph_insert_stmt, 11, graph->breakpoint_size);
147	if (graph->breakpoint_size && graph->breakpoints)
148		sqlite3_bind_blob(graph_insert_stmt, 12, pos, sizeof(int) * graph->breakpoint_size, 0);
149	sqlite3_bind_int(graph_insert_stmt, 13, graph->backward.tensor_symbol_size);
150	if (graph->backward.tensor_symbol_size)
151		sqlite3_bind_blob(graph_insert_stmt, 14, graph->backward.tensor_symbol_idx, sizeof(int) * graph->backward.tensor_symbol_size, 0);
152	sqlite3_bind_int(graph_insert_stmt, 15, graph->backward.exec_symbol_size);
153	if (graph->backward.exec_symbol_size)
154		sqlite3_bind_blob(graph_insert_stmt, 16, graph->backward.exec_symbol_idx, sizeof(int) * graph->backward.exec_symbol_size, 0);
155	sqlite3_bind_int(graph_insert_stmt, 17, graph->data_parallel.count);
156	sqlite3_bind_int(graph_insert_stmt, 18, graph->data_parallel.tensor_symbol_size);
157	if (graph->data_parallel.tensor_symbol_idx)
158		sqlite3_bind_blob(graph_insert_stmt, 19, graph->data_parallel.tensor_symbol_idx, sizeof(int) * graph->data_parallel.tensor_symbol_size, 0);
159	sqlite3_bind_int(graph_insert_stmt, 20, graph->data_parallel.exec_symbol_size);
160	if (graph->data_parallel.exec_symbol_idx)
161		sqlite3_bind_blob(graph_insert_stmt, 21, graph->data_parallel.exec_symbol_idx, sizeof(int) * graph->data_parallel.exec_symbol_size, 0);
162	SQLITE_ENFORCE(SQLITE_DONE == sqlite3_step(graph_insert_stmt))((void) sizeof ((101 == sqlite3_step(graph_insert_stmt)) ? 1 :
 0), __extension__ ({ if (101 == sqlite3_step(graph_insert_stmt
)) ; else __assert_fail ("SQLITE_DONE == sqlite3_step(graph_insert_stmt)"
, "ccv_nnc_symbolic_graph_io.c", 162, __extension__ __PRETTY_FUNCTION__
); }));
163	sqlite3_reset(graph_insert_stmt);
164	sqlite3_clear_bindings(graph_insert_stmt);
165}
166 
167static void _ccv_nnc_symbolic_graph_push_repo(const ccv_nnc_symbolic_graph_t* const graph, ccv_array_t* const repo)
168{
169	ccv_array_push(repo, &graph);
170	int i;
171	if (graph->sub_graphs && graph->sub_graphs->rnum)
172		for (i = 0; i < graph->sub_graphs->rnum; i++)
173		{
174			const ccv_nnc_symbolic_graph_t* const sub_graph = *(ccv_nnc_symbolic_graph_t**)ccv_array_get(graph->sub_graphs, i)((void*)(((char*)((graph->sub_graphs)->data)) + (size_t
)(graph->sub_graphs)->rsize * (size_t)(i)));
175			if (sub_graph)
176				_ccv_nnc_symbolic_graph_push_repo(sub_graph, repo);
177		}
178}
179 
180void ccv_nnc_symbolic_graph_write(const ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_bind_t* const tensor_binds, const int tensor_bind_size, const char* const fn)
181{
182	sqlite3* conn = 0;
183	if (SQLITE_OK0 != sqlite3_open(fn, &conn))
184		return;
185	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, "BEGIN", 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, "BEGIN", 0, 0, 0)) ?
 1 : 0), __extension__ ({ if (0 == sqlite3_exec(conn, "BEGIN"
, 0, 0, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_exec(conn, \"BEGIN\", 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 185, __extension__ __PRETTY_FUNCTION__
); }));
186	const char tensor_symbol_create_table_qs[] = "CREATE TABLE IF NOT EXISTS tensor_symbol "
187		"(id INTEGER, graph INTEGER, assign_ref INTEGER, r_assign_ref INTEGER, "
188		"bypass_ref INTEGER, r_bypass_ref INTEGER, p_ref INTEGER, alias_ref INTEGER, pair_ref INTEGER, "
189		"flags INTEGER, ofs BLOB, stride BLOB, s_ref BLOB, name TEXT, type INTEGER, format INTEGER, "
190		"datatype INTEGER, dim BLOB, PRIMARY KEY (id, graph))";
191	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, tensor_symbol_create_table_qs, 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, tensor_symbol_create_table_qs
, 0, 0, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_exec(
conn, tensor_symbol_create_table_qs, 0, 0, 0)) ; else __assert_fail
 ("SQLITE_OK == sqlite3_exec(conn, tensor_symbol_create_table_qs, 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 191, __extension__ __PRETTY_FUNCTION__
); }));
192	const char tensor_symbol_insert_qs[] = 
193		"REPLACE INTO tensor_symbol "
194		"(id, graph, assign_ref, r_assign_ref, bypass_ref, r_bypass_ref, p_ref, alias_ref, pair_ref, flags, "
195		"ofs, stride, s_ref, name, type, format, datatype, dim) VALUES "
196		"($id, $graph, $assign_ref, $r_assign_ref, $bypass_ref, $r_bypass_ref, $p_ref, $alias_ref, $pair_ref, "
197		"$flags, $ofs, $stride, $s_ref, $name, $type, $format, $datatype, $dim)";
198	sqlite3_stmt* tensor_symbol_insert_stmt = 0;
199	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, tensor_symbol_insert_qs, sizeof(tensor_symbol_insert_qs), &tensor_symbol_insert_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, tensor_symbol_insert_qs
, sizeof(tensor_symbol_insert_qs), &tensor_symbol_insert_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, tensor_symbol_insert_qs, sizeof(tensor_symbol_insert_qs
), &tensor_symbol_insert_stmt, 0)) ; else __assert_fail (
"SQLITE_OK == sqlite3_prepare_v2(conn, tensor_symbol_insert_qs, sizeof(tensor_symbol_insert_qs), &tensor_symbol_insert_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 199, __extension__ __PRETTY_FUNCTION__
); }));
200 
201	const char exec_symbol_create_table_qs[] = "CREATE TABLE IF NOT EXISTS graph_exec_symbol "
202		"(id INTEGER, graph INTEGER, input_size INTEGER, output_size INTEGER, graph_ref_size INTEGER, "
203		"flags INTEGER, pair_ref INTEGER, inputs BLOB, outputs BLOB, outgoings BLOB, name TEXT, "
204		"cmd_cmd INTEGER, cmd_backend INTEGER, cmd_algorithm INTEGER, cmd_info BLOB, hint BLOB, graph_ref BLOB, "
205		"case_of_expr INTEGER, case_of_flags INTEGER, case_of_argument_offset INTEGER, case_of_argument_size INTEGER, "
206		"p_while_expr INTEGER, p_while_input_size INTEGER, p_while_inputs BLOB, PRIMARY KEY (id, graph))";
207	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, exec_symbol_create_table_qs, 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, exec_symbol_create_table_qs
, 0, 0, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_exec(
conn, exec_symbol_create_table_qs, 0, 0, 0)) ; else __assert_fail
 ("SQLITE_OK == sqlite3_exec(conn, exec_symbol_create_table_qs, 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 207, __extension__ __PRETTY_FUNCTION__
); }));
208	const char exec_symbol_insert_qs[] = 
209		"REPLACE INTO graph_exec_symbol "
210		"(id, graph, input_size, output_size, graph_ref_size, flags, pair_ref, inputs, outputs, outgoings, "
211		"name, cmd_cmd, cmd_backend, cmd_algorithm, cmd_info, hint, graph_ref, case_of_expr, case_of_flags, "
212		"case_of_argument_offset, case_of_argument_size, p_while_expr, p_while_input_size, p_while_inputs) "
213		"VALUES ($id, $graph, $input_size, $output_size, $graph_ref_size, $flags, $pair_ref, $inputs, $outputs, "
214		"$outgoings, $name, $cmd_cmd, $cmd_backend, $cmd_algorithm, $cmd_info, $hint, $graph_ref, $case_of_expr, "
215		"$case_of_flags, $case_of_argument_offset, $case_of_argument_size, $p_while_expr, $p_while_input_size, "
216		"$p_while_inputs)";
217	sqlite3_stmt* exec_symbol_insert_stmt = 0;
218	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, exec_symbol_insert_qs, sizeof(exec_symbol_insert_qs), &exec_symbol_insert_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, exec_symbol_insert_qs
, sizeof(exec_symbol_insert_qs), &exec_symbol_insert_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, exec_symbol_insert_qs, sizeof(exec_symbol_insert_qs), &
exec_symbol_insert_stmt, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, exec_symbol_insert_qs, sizeof(exec_symbol_insert_qs), &exec_symbol_insert_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 218, __extension__ __PRETTY_FUNCTION__
); }));
219 
220	const char graph_create_table_qs[] = "CREATE TABLE IF NOT EXISTS graph "
221		"(graph INTEGER PRIMARY KEY, tensor_symbol_size INTEGER, exec_symbol_size INTEGER, sources BLOB, "
222		"destinations BLOB, sub_graphs BLOB, pair INTEGER, p INTEGER, p_idx INTEGER, exec_idx INTEGER, "
223		"breakpoint_size INTEGER, breakpoints BLOB, backward_tensor_symbol_size INTEGER, "
224		"backward_tensor_symbol_idx BLOB, backward_exec_symbol_size INTEGER, backward_exec_symbol_idx BLOB, "
225		"parallel_count INTEGER, parallel_tensor_symbol_size INTEGER, parallel_tensor_symbol_idx BLOB, "
226		"parallel_exec_symbol_size INTEGER, parallel_exec_symbol_idx BLOB)";
227	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, graph_create_table_qs, 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, graph_create_table_qs
, 0, 0, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_exec(
conn, graph_create_table_qs, 0, 0, 0)) ; else __assert_fail (
"SQLITE_OK == sqlite3_exec(conn, graph_create_table_qs, 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 227, __extension__ __PRETTY_FUNCTION__
); }));
228	const char graph_insert_qs[] = 
229		"REPLACE INTO graph "
230		"(graph, tensor_symbol_size, exec_symbol_size, sources, destinations, sub_graphs, pair, p, p_idx, "
231		"exec_idx, breakpoint_size, breakpoints, backward_tensor_symbol_size, "
232		"backward_tensor_symbol_idx, backward_exec_symbol_size, backward_exec_symbol_idx, "
233		"parallel_count, parallel_tensor_symbol_size, parallel_tensor_symbol_idx, "
234		"parallel_exec_symbol_size, parallel_exec_symbol_idx) VALUES "
235		"($graph, $tensor_symbol_size, $exec_symbol_size, $sources, $destinations, $sub_graphs, $pair, $p, $p_idx, "
236		"$exec_idx, $breakpoint_size, $breakpoints, $backward_tensor_symbol_size, "
237		"$backward_tensor_symbol_idx, $backward_exec_symbol_size, $backward_exec_symbol_idx, "
238		"$parallel_count, $parallel_tensor_symbol_size, $parallel_tensor_symbol_idx, "
239		"$parallel_exec_symbol_size, $parallel_exec_symbol_idx)";
240	sqlite3_stmt* graph_insert_stmt = 0;
241	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, graph_insert_qs, sizeof(graph_insert_qs), &graph_insert_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, graph_insert_qs
, sizeof(graph_insert_qs), &graph_insert_stmt, 0)) ? 1 : 0
), __extension__ ({ if (0 == sqlite3_prepare_v2(conn, graph_insert_qs
, sizeof(graph_insert_qs), &graph_insert_stmt, 0)) ; else
 __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, graph_insert_qs, sizeof(graph_insert_qs), &graph_insert_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 241, __extension__ __PRETTY_FUNCTION__
); }));
242	ccv_array_t* const repo = ccv_array_new(sizeof(ccv_nnc_symbolic_graph_t*), 1, 0);
243	_ccv_nnc_symbolic_graph_push_repo(graph, repo);
244	ccv_array_t* const ws = ccv_array_new(sizeof(int), 1, 0);
245	int i;
246	for (i = 0; i < repo->rnum; i++)
247		_ccv_nnc_symbolic_graph_write(*(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, i)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(i))), repo, i,
248			tensor_symbol_insert_stmt, exec_symbol_insert_stmt, graph_insert_stmt, ws);
249	ccv_array_free(ws);
250	sqlite3_finalize(tensor_symbol_insert_stmt);
251	sqlite3_finalize(exec_symbol_insert_stmt);
252	sqlite3_finalize(graph_insert_stmt);
253	// Write tensor binds.
254	const char tensor_bind_create_table_qs[] = "CREATE TABLE IF NOT EXISTS tensor_bind "
255		"(id INTEGER, graph INTEGER, type INTEGER, format INTEGER, datatype INTEGER, "
256		"dim BLOB, data BLOB, PRIMARY KEY (id, graph))";
257	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, tensor_bind_create_table_qs, 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, tensor_bind_create_table_qs
, 0, 0, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_exec(
conn, tensor_bind_create_table_qs, 0, 0, 0)) ; else __assert_fail
 ("SQLITE_OK == sqlite3_exec(conn, tensor_bind_create_table_qs, 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 257, __extension__ __PRETTY_FUNCTION__
); }));
258	// Remove everything in that table.
259	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, "DELETE FROM tensor_bind", 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, "DELETE FROM tensor_bind"
, 0, 0, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_exec(
conn, "DELETE FROM tensor_bind", 0, 0, 0)) ; else __assert_fail
 ("SQLITE_OK == sqlite3_exec(conn, \"DELETE FROM tensor_bind\", 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 259, __extension__ __PRETTY_FUNCTION__
); }));
260	const char tensor_bind_insert_qs[] =
261		"REPLACE INTO tensor_bind "
262		"(id, graph, type, format, datatype, dim, data) VALUES ("
263		"$id, $graph, $type, $format, $datatype, $dim, $data)";
264	sqlite3_stmt* tensor_bind_insert_stmt = 0;
265	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_insert_qs, sizeof(tensor_bind_insert_qs), &tensor_bind_insert_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, tensor_bind_insert_qs
, sizeof(tensor_bind_insert_qs), &tensor_bind_insert_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, tensor_bind_insert_qs, sizeof(tensor_bind_insert_qs), &
tensor_bind_insert_stmt, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_insert_qs, sizeof(tensor_bind_insert_qs), &tensor_bind_insert_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 265, __extension__ __PRETTY_FUNCTION__
); }));
266#ifdef HAVE_CUDA1
267	size_t workspace_size = 0;
268	void* workspace = 0;
269#endif
270	for (i = 0; i < tensor_bind_size; i++)
271	{
272		const int graph_idx = _ccv_nnc_symbolic_graph_index_in_repo(tensor_binds[i].symbol.graph, repo);
273		if (graph_idx < 0)
274			continue;
275		sqlite3_bind_int(tensor_bind_insert_stmt, 1, tensor_binds[i].symbol.d);
276		sqlite3_bind_int(tensor_bind_insert_stmt, 2, graph_idx);
277		if (tensor_binds[i].tensor)
278		{
279			const ccv_nnc_tensor_t* const tensor = tensor_binds[i].tensor;
280			assert(!CCV_IS_TENSOR_VIEW(tensor))((void) sizeof ((!((*(int*)(tensor)) & CCV_TENSOR_VIEW)) ?
 1 : 0), __extension__ ({ if (!((*(int*)(tensor)) & CCV_TENSOR_VIEW
)) ; else __assert_fail ("!CCV_IS_TENSOR_VIEW(tensor)", "ccv_nnc_symbolic_graph_io.c"
, 280, __extension__ __PRETTY_FUNCTION__); }));
281			sqlite3_bind_int(tensor_bind_insert_stmt, 3, tensor->info.type);
282			sqlite3_bind_int(tensor_bind_insert_stmt, 4, tensor->info.format);
283			sqlite3_bind_int(tensor_bind_insert_stmt, 5, tensor->info.datatype);
284			sqlite3_bind_blob(tensor_bind_insert_stmt, 6, tensor->info.dim, sizeof(tensor->info.dim), 0);
285			const size_t data_size = ccv_nnc_tensor_data_size(tensor->info);
286#ifdef HAVE_CUDA1
287			if (CCV_TENSOR_GET_MEMORY(tensor->info.type)((tensor->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY)
288			{
289				if (!workspace)
290				{
291					workspace = ccmallocmalloc(data_size);
292					workspace_size = data_size;
293				} else if (data_size > workspace_size) {
294					workspace = ccreallocrealloc(workspace, data_size);
295					workspace_size = data_size;
296				}
297				cumemcpy(workspace, CCV_TENSOR_CPU_MEMORY, tensor->data.u8, tensor->info.type, data_size);
298				sqlite3_bind_blob(tensor_bind_insert_stmt, 7, workspace, data_size, 0);
299			} else
300				sqlite3_bind_blob(tensor_bind_insert_stmt, 7, tensor->data.u8, data_size, 0);
301#else
302			sqlite3_bind_blob(tensor_bind_insert_stmt, 7, tensor->data.u8, data_size, 0);
303#endif
304		} else {
305			assert(tensor_binds[i].symbol.d >= 0)((void) sizeof ((tensor_binds[i].symbol.d >= 0) ? 1 : 0), __extension__
 ({ if (tensor_binds[i].symbol.d >= 0) ; else __assert_fail
 ("tensor_binds[i].symbol.d >= 0", "ccv_nnc_symbolic_graph_io.c"
, 305, __extension__ __PRETTY_FUNCTION__); }));
306			const ccv_nnc_tensor_symbol_info_t* const symbol_info = (ccv_nnc_tensor_symbol_info_t*)ccv_array_get(graph->tensor_symbol_info, tensor_binds[i].symbol.d)((void*)(((char*)((graph->tensor_symbol_info)->data)) +
 (size_t)(graph->tensor_symbol_info)->rsize * (size_t)(
tensor_binds[i].symbol.d)));
307			sqlite3_bind_int(tensor_bind_insert_stmt, 3, symbol_info->info.type);
308			sqlite3_bind_int(tensor_bind_insert_stmt, 4, symbol_info->info.format);
309			sqlite3_bind_int(tensor_bind_insert_stmt, 5, symbol_info->info.datatype);
310			sqlite3_bind_blob(tensor_bind_insert_stmt, 6, symbol_info->info.dim, sizeof(symbol_info->info.dim), 0);
311		}
312		sqlite3_step(tensor_bind_insert_stmt);
313		sqlite3_reset(tensor_bind_insert_stmt);
314		sqlite3_clear_bindings(tensor_bind_insert_stmt);
315	}
316	sqlite3_finalize(tensor_bind_insert_stmt);
317#ifdef HAVE_CUDA1
318	if (workspace)
319		ccfreefree(workspace);
320#endif
321	ccv_array_free(repo);
322	SQLITE_ENFORCE(SQLITE_OK == sqlite3_exec(conn, "COMMIT", 0, 0, 0))((void) sizeof ((0 == sqlite3_exec(conn, "COMMIT", 0, 0, 0)) ?
 1 : 0), __extension__ ({ if (0 == sqlite3_exec(conn, "COMMIT"
, 0, 0, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_exec(conn, \"COMMIT\", 0, 0, 0)"
, "ccv_nnc_symbolic_graph_io.c", 322, __extension__ __PRETTY_FUNCTION__
); }));
323	sqlite3_close(conn);
324}
325 
326static ccv_nnc_symbolic_graph_t* _ccv_nnc_symbolic_graph_get(const ccv_array_t* const repo, const ccv_nnc_symbolic_graph_t* const pos)
327{
328	const int idx = (uintptr_t)pos >> 1;
329	assert(idx < repo->rnum)((void) sizeof ((idx < repo->rnum) ? 1 : 0), __extension__
 ({ if (idx < repo->rnum) ; else __assert_fail ("idx < repo->rnum"
, "ccv_nnc_symbolic_graph_io.c", 329, __extension__ __PRETTY_FUNCTION__
); }));
330	return *(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, idx)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(idx)));
331}
332 
333#define CCV_NNC_IS_SYMBOLIC_GRAPH_POS(ptr)((uintptr_t)(ptr) & 1) ((uintptr_t)(ptr) & 1)
334 
335static ccv_nnc_symbolic_graph_t* _ccv_nnc_symbolic_graph_pos(const int idx)
336{
337	if (idx < 0)
338		return 0; // This is nil.
339	return (ccv_nnc_symbolic_graph_t*)(((uintptr_t)idx << 1) + 1);
340}
341 
342static void _ccv_nnc_symbolic_graph_read(const int graph_idx, sqlite3_stmt* const graph_select_stmt, sqlite3_stmt* const tensor_symbol_select_stmt, sqlite3_stmt* const exec_symbol_select_stmt, ccv_nnc_symbolic_graph_t* const graph)
343{
344	int i, j;
345	ccv_array_resize(graph->tensor_symbol_info, sqlite3_column_int(graph_select_stmt, 1));
346	ccv_array_resize(graph->exec_symbol_info, sqlite3_column_int(graph_select_stmt, 2));
347	if (sqlite3_column_blob(graph_select_stmt, 3))
348	{
349		const int* const sources = sqlite3_column_blob(graph_select_stmt, 3);
350		const int count = sqlite3_column_bytes(graph_select_stmt, 3) / sizeof(int);
351		graph->sources = ccv_array_new(sizeof(ccv_nnc_graph_exec_symbol_t), count, 0);
352		for (i = 0; i < count; i++)
353		{
354			const ccv_nnc_graph_exec_symbol_t symbol = {
355				.graph = graph,
356				.d = sources[i]
357			};
358			ccv_array_push(graph->sources, &symbol);
359		}
360	}
361	if (sqlite3_column_blob(graph_select_stmt, 4))
362	{
363		const int* const destinations = sqlite3_column_blob(graph_select_stmt, 4);
364		const int count = sqlite3_column_bytes(graph_select_stmt, 4) / sizeof(int);
365		graph->destinations = ccv_array_new(sizeof(ccv_nnc_graph_exec_symbol_t), count, 0);
366		for (i = 0; i < count; i++)
367		{
368			const ccv_nnc_graph_exec_symbol_t symbol = {
369				.graph = graph,
370				.d = destinations[i]
371			};
372			ccv_array_push(graph->destinations, &symbol);
373		}
374	}
375	if (sqlite3_column_blob(graph_select_stmt, 5))
376	{
377		const int* const sub_graphs = sqlite3_column_blob(graph_select_stmt, 5);
378		const int count = sqlite3_column_bytes(graph_select_stmt, 5) / sizeof(int);
379		graph->sub_graphs = ccv_array_new(sizeof(ccv_nnc_symbolic_graph_t*), count, 0);
380		for (i = 0; i < count; i++)
381		{
382			const ccv_nnc_symbolic_graph_t* const sub_graph = _ccv_nnc_symbolic_graph_pos(sub_graphs[i]);
383			ccv_array_push(graph->sub_graphs, &sub_graph);
384		}
385	}
386	graph->pair = _ccv_nnc_symbolic_graph_pos(sqlite3_column_int(graph_select_stmt, 6));
387	graph->p = _ccv_nnc_symbolic_graph_pos(sqlite3_column_int(graph_select_stmt, 7));
388	graph->p_idx = sqlite3_column_int(graph_select_stmt, 8);
389	graph->exec_idx = sqlite3_column_int(graph_select_stmt, 9);
390	graph->breakpoint_size = sqlite3_column_int(graph_select_stmt, 10);
391	if (graph->breakpoint_size)
392	{
393		graph->breakpoints = (ccv_nnc_graph_exec_symbol_t*)ccmallocmalloc(sizeof(ccv_nnc_graph_exec_symbol_t) * graph->breakpoint_size);
394		assert(sizeof(int) * graph->breakpoint_size == sqlite3_column_bytes(graph_select_stmt, 11))((void) sizeof ((sizeof(int) * graph->breakpoint_size == sqlite3_column_bytes
(graph_select_stmt, 11)) ? 1 : 0), __extension__ ({ if (sizeof
(int) * graph->breakpoint_size == sqlite3_column_bytes(graph_select_stmt
, 11)) ; else __assert_fail ("sizeof(int) * graph->breakpoint_size == sqlite3_column_bytes(graph_select_stmt, 11)"
, "ccv_nnc_symbolic_graph_io.c", 394, __extension__ __PRETTY_FUNCTION__
); }));
395		const int* const breakpoints = sqlite3_column_blob(graph_select_stmt, 11);
396		for (i = 0; i < graph->breakpoint_size; i++)
397			graph->breakpoints[i] = (ccv_nnc_graph_exec_symbol_t){
398				.d = breakpoints[i],
399				.graph = graph
400			};
401	}
402	graph->backward.tensor_symbol_size = sqlite3_column_int(graph_select_stmt, 12);
403	graph->backward.exec_symbol_size = sqlite3_column_int(graph_select_stmt, 14);
404	if (graph->backward.tensor_symbol_size || graph->backward.exec_symbol_size)
405		graph->backward.tensor_symbol_idx = (int*)ccmallocmalloc(sizeof(int) * (graph->backward.tensor_symbol_size + graph->backward.exec_symbol_size));
406	if (graph->backward.tensor_symbol_size)
407	{
408		assert(sizeof(int) * graph->backward.tensor_symbol_size == sqlite3_column_bytes(graph_select_stmt, 13))((void) sizeof ((sizeof(int) * graph->backward.tensor_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 13)) ? 1 : 0), __extension__
 ({ if (sizeof(int) * graph->backward.tensor_symbol_size ==
 sqlite3_column_bytes(graph_select_stmt, 13)) ; else __assert_fail
 ("sizeof(int) * graph->backward.tensor_symbol_size == sqlite3_column_bytes(graph_select_stmt, 13)"
, "ccv_nnc_symbolic_graph_io.c", 408, __extension__ __PRETTY_FUNCTION__
); }));
409		const int* const backward_tensor_symbol_idx = sqlite3_column_blob(graph_select_stmt, 13);
410		memcpy(graph->backward.tensor_symbol_idx, backward_tensor_symbol_idx, sizeof(int) * graph->backward.tensor_symbol_size);
411	}
412	if (graph->backward.exec_symbol_size)
413	{
414		graph->backward.exec_symbol_idx = graph->backward.tensor_symbol_idx + graph->backward.tensor_symbol_size;
415		assert(sizeof(int) * graph->backward.exec_symbol_size == sqlite3_column_bytes(graph_select_stmt, 15))((void) sizeof ((sizeof(int) * graph->backward.exec_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 15)) ? 1 : 0), __extension__
 ({ if (sizeof(int) * graph->backward.exec_symbol_size == sqlite3_column_bytes
(graph_select_stmt, 15)) ; else __assert_fail ("sizeof(int) * graph->backward.exec_symbol_size == sqlite3_column_bytes(graph_select_stmt, 15)"
, "ccv_nnc_symbolic_graph_io.c", 415, __extension__ __PRETTY_FUNCTION__
); }));
416		const int* const backward_exec_symbol_idx = sqlite3_column_blob(graph_select_stmt, 15);
417		memcpy(graph->backward.exec_symbol_idx, backward_exec_symbol_idx, sizeof(int) * graph->backward.exec_symbol_size);
418	}
419	graph->data_parallel.count = sqlite3_column_int(graph_select_stmt, 16);
420	graph->data_parallel.tensor_symbol_size = sqlite3_column_int(graph_select_stmt, 17);
421	if (graph->data_parallel.tensor_symbol_size)
422	{
423		graph->data_parallel.tensor_symbol_idx = (int*)ccmallocmalloc(sizeof(int) * graph->data_parallel.tensor_symbol_size);
424		assert(sizeof(int) * graph->data_parallel.tensor_symbol_size == sqlite3_column_bytes(graph_select_stmt, 18))((void) sizeof ((sizeof(int) * graph->data_parallel.tensor_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 18)) ? 1 : 0), __extension__
 ({ if (sizeof(int) * graph->data_parallel.tensor_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 18)) ; else __assert_fail
 ("sizeof(int) * graph->data_parallel.tensor_symbol_size == sqlite3_column_bytes(graph_select_stmt, 18)"
, "ccv_nnc_symbolic_graph_io.c", 424, __extension__ __PRETTY_FUNCTION__
); }));
425		const int* const parallel_tensor_symbol_idx = sqlite3_column_blob(graph_select_stmt, 18);
426		memcpy(graph->data_parallel.tensor_symbol_idx, parallel_tensor_symbol_idx, sizeof(int) * graph->data_parallel.tensor_symbol_size);
427	}
428	graph->data_parallel.exec_symbol_size = sqlite3_column_int(graph_select_stmt, 19);
429	if (graph->data_parallel.exec_symbol_size)
430	{
431		graph->data_parallel.exec_symbol_idx = (int*)ccmallocmalloc(sizeof(int) * graph->data_parallel.exec_symbol_size);
432		assert(sizeof(int) * graph->data_parallel.exec_symbol_size == sqlite3_column_bytes(graph_select_stmt, 20))((void) sizeof ((sizeof(int) * graph->data_parallel.exec_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 20)) ? 1 : 0), __extension__
 ({ if (sizeof(int) * graph->data_parallel.exec_symbol_size
 == sqlite3_column_bytes(graph_select_stmt, 20)) ; else __assert_fail
 ("sizeof(int) * graph->data_parallel.exec_symbol_size == sqlite3_column_bytes(graph_select_stmt, 20)"
, "ccv_nnc_symbolic_graph_io.c", 432, __extension__ __PRETTY_FUNCTION__
); }));
433		const int* const parallel_exec_symbol_idx = sqlite3_column_blob(graph_select_stmt, 20);
434		memcpy(graph->data_parallel.exec_symbol_idx, parallel_exec_symbol_idx, sizeof(int) * graph->data_parallel.exec_symbol_size);
435	}
436	sqlite3_bind_int(tensor_symbol_select_stmt, 1, graph_idx);
437	for (i = 0; SQLITE_ROW100 == sqlite3_step(tensor_symbol_select_stmt); i++)
438	{
439		assert(sqlite3_column_int(tensor_symbol_select_stmt, 0) == i)((void) sizeof ((sqlite3_column_int(tensor_symbol_select_stmt
, 0) == i) ? 1 : 0), __extension__ ({ if (sqlite3_column_int(
tensor_symbol_select_stmt, 0) == i) ; else __assert_fail ("sqlite3_column_int(tensor_symbol_select_stmt, 0) == i"
, "ccv_nnc_symbolic_graph_io.c", 439, __extension__ __PRETTY_FUNCTION__
); })); // id should match.
440		assert(i < graph->tensor_symbol_info->rnum)((void) sizeof ((i < graph->tensor_symbol_info->rnum
) ? 1 : 0), __extension__ ({ if (i < graph->tensor_symbol_info
->rnum) ; else __assert_fail ("i < graph->tensor_symbol_info->rnum"
, "ccv_nnc_symbolic_graph_io.c", 440, __extension__ __PRETTY_FUNCTION__
); }));
441		assert(sqlite3_column_int(tensor_symbol_select_stmt, 0) == i)((void) sizeof ((sqlite3_column_int(tensor_symbol_select_stmt
, 0) == i) ? 1 : 0), __extension__ ({ if (sqlite3_column_int(
tensor_symbol_select_stmt, 0) == i) ; else __assert_fail ("sqlite3_column_int(tensor_symbol_select_stmt, 0) == i"
, "ccv_nnc_symbolic_graph_io.c", 441, __extension__ __PRETTY_FUNCTION__
); }));
442		ccv_nnc_tensor_symbol_info_t* const symbol_info = (ccv_nnc_tensor_symbol_info_t*)ccv_array_get(graph->tensor_symbol_info, i)((void*)(((char*)((graph->tensor_symbol_info)->data)) +
 (size_t)(graph->tensor_symbol_info)->rsize * (size_t)(
i)));
443		symbol_info->assign_ref = sqlite3_column_int(tensor_symbol_select_stmt, 1);
444		symbol_info->r_assign_ref = sqlite3_column_int(tensor_symbol_select_stmt, 2);
445		symbol_info->bypass_ref = sqlite3_column_int(tensor_symbol_select_stmt, 3);
446		symbol_info->r_bypass_ref = sqlite3_column_int(tensor_symbol_select_stmt, 4);
447		symbol_info->p_ref = sqlite3_column_int(tensor_symbol_select_stmt, 5);
448		symbol_info->alias_ref = sqlite3_column_int(tensor_symbol_select_stmt, 6);
449		symbol_info->pair_ref = sqlite3_column_int(tensor_symbol_select_stmt, 7);
450		symbol_info->flags = sqlite3_column_int(tensor_symbol_select_stmt, 8);
451		memset(symbol_info->ofs, 0, sizeof(symbol_info->ofs));
452		const int* const ofs = sqlite3_column_blob(tensor_symbol_select_stmt, 9);
453		if (ofs)
454			memcpy(symbol_info->ofs, ofs, ccv_min(sqlite3_column_bytes(tensor_symbol_select_stmt, 8), sizeof(symbol_info->ofs))({ typeof (sqlite3_column_bytes(tensor_symbol_select_stmt, 8)
) _a = (sqlite3_column_bytes(tensor_symbol_select_stmt, 8)); typeof
 (sizeof(symbol_info->ofs)) _b = (sizeof(symbol_info->ofs
)); (_a < _b) ? _a : _b; }));
455		memset(symbol_info->stride, 0, sizeof(symbol_info->stride));
456		const int* const stride = sqlite3_column_blob(tensor_symbol_select_stmt, 10);
457		if (stride)
458			memcpy(symbol_info->stride, stride, ccv_min(sqlite3_column_bytes(tensor_symbol_select_stmt, 9), sizeof(symbol_info->stride))({ typeof (sqlite3_column_bytes(tensor_symbol_select_stmt, 9)
) _a = (sqlite3_column_bytes(tensor_symbol_select_stmt, 9)); typeof
 (sizeof(symbol_info->stride)) _b = (sizeof(symbol_info->
stride)); (_a < _b) ? _a : _b; }));
459		const int* const s_ref = sqlite3_column_blob(tensor_symbol_select_stmt, 11);
460		if (s_ref)
461		{
462			const int count = sqlite3_column_bytes(tensor_symbol_select_stmt, 11) / sizeof(int);
463			symbol_info->s_ref = ccv_array_new(sizeof(int), count, 0);
464			ccv_array_resize(symbol_info->s_ref, count);
465			memcpy(ccv_array_get(symbol_info->s_ref, 0)((void*)(((char*)((symbol_info->s_ref)->data)) + (size_t
)(symbol_info->s_ref)->rsize * (size_t)(0))), s_ref, sizeof(int) * count);
466		} else
467			symbol_info->s_ref = 0;
468		const char* const name = (char*)sqlite3_column_text(tensor_symbol_select_stmt, 12);
469		if (name)
470		{
471			const int count = sqlite3_column_bytes(tensor_symbol_select_stmt, 12);
472			symbol_info->name = (char*)ccmallocmalloc(sizeof(char) * (count + 1));
473			memcpy(symbol_info->name, name, count);
474			symbol_info->name[count] = 0; // null terminator
475		} else
476			symbol_info->name = 0;
477		symbol_info->info.type = sqlite3_column_int(tensor_symbol_select_stmt, 13);
478		symbol_info->info.format = sqlite3_column_int(tensor_symbol_select_stmt, 14);
479		symbol_info->info.datatype = sqlite3_column_int(tensor_symbol_select_stmt, 15);
480		memset(symbol_info->info.dim, 0, sizeof(symbol_info->info.dim));
481		const int* const dim = sqlite3_column_blob(tensor_symbol_select_stmt, 16);
482		if (dim)
483			memcpy(symbol_info->info.dim, dim, ccv_min(sqlite3_column_bytes(tensor_symbol_select_stmt, 16), sizeof(symbol_info->info.dim))({ typeof (sqlite3_column_bytes(tensor_symbol_select_stmt, 16
)) _a = (sqlite3_column_bytes(tensor_symbol_select_stmt, 16))
; typeof (sizeof(symbol_info->info.dim)) _b = (sizeof(symbol_info
->info.dim)); (_a < _b) ? _a : _b; }));
484		if (CCV_NNC_TENSOR_SYMBOL_IS_DEAD(symbol_info->flags)((symbol_info->flags) & CCV_NNC_TENSOR_SYMBOL_DEAD) && graph->reuse.tensor < 0)
485			graph->reuse.tensor = i;
486	}
487	sqlite3_reset(tensor_symbol_select_stmt);
488	sqlite3_clear_bindings(tensor_symbol_select_stmt);
489	sqlite3_bind_int(exec_symbol_select_stmt, 1, graph_idx);
490	for (i = 0; SQLITE_ROW100 == sqlite3_step(exec_symbol_select_stmt); i++)
491	{
492		assert(sqlite3_column_int(exec_symbol_select_stmt, 0) == i)((void) sizeof ((sqlite3_column_int(exec_symbol_select_stmt, 0
) == i) ? 1 : 0), __extension__ ({ if (sqlite3_column_int(exec_symbol_select_stmt
, 0) == i) ; else __assert_fail ("sqlite3_column_int(exec_symbol_select_stmt, 0) == i"
, "ccv_nnc_symbolic_graph_io.c", 492, __extension__ __PRETTY_FUNCTION__
); })); // id should match.
493		assert(i < graph->exec_symbol_info->rnum)((void) sizeof ((i < graph->exec_symbol_info->rnum) ?
 1 : 0), __extension__ ({ if (i < graph->exec_symbol_info
->rnum) ; else __assert_fail ("i < graph->exec_symbol_info->rnum"
, "ccv_nnc_symbolic_graph_io.c", 493, __extension__ __PRETTY_FUNCTION__
); }));
494		assert(sqlite3_column_int(exec_symbol_select_stmt, 0) == i)((void) sizeof ((sqlite3_column_int(exec_symbol_select_stmt, 0
) == i) ? 1 : 0), __extension__ ({ if (sqlite3_column_int(exec_symbol_select_stmt
, 0) == i) ; else __assert_fail ("sqlite3_column_int(exec_symbol_select_stmt, 0) == i"
, "ccv_nnc_symbolic_graph_io.c", 494, __extension__ __PRETTY_FUNCTION__
); }));
495		ccv_nnc_graph_exec_symbol_info_t* const symbol_info = (ccv_nnc_graph_exec_symbol_info_t*)ccv_array_get(graph->exec_symbol_info, i)((void*)(((char*)((graph->exec_symbol_info)->data)) + (
size_t)(graph->exec_symbol_info)->rsize * (size_t)(i)));
496		memset(symbol_info, 0, sizeof(ccv_nnc_graph_exec_symbol_info_t));
497		symbol_info->input_size = sqlite3_column_int(exec_symbol_select_stmt, 1);
498		symbol_info->output_size = sqlite3_column_int(exec_symbol_select_stmt, 2);
499		symbol_info->graph_ref_size = sqlite3_column_int(exec_symbol_select_stmt, 3);
500		symbol_info->flags = sqlite3_column_int(exec_symbol_select_stmt, 4);
501		symbol_info->pair_ref = sqlite3_column_int(exec_symbol_select_stmt, 5);
502		if (symbol_info->input_size > 0 || symbol_info->output_size > 0)
503		{
504			symbol_info->inputs = (int*)ccmallocmalloc(sizeof(int) * (symbol_info->input_size + symbol_info->output_size));
505			for (j = 0; j < symbol_info->input_size; j++)
506				symbol_info->inputs[j] = CCV_NNC_NO_TENSOR_SYMBOL;
507			symbol_info->outputs = symbol_info->inputs + symbol_info->input_size;
508			for (j = 0; j < symbol_info->output_size; j++)
509				symbol_info->outputs[j] = CCV_NNC_NO_TENSOR_SYMBOL;
510		}
511		if (symbol_info->input_size)
512		{
513			const int* const inputs = sqlite3_column_blob(exec_symbol_select_stmt, 6);
514			if (inputs)
515				memcpy(symbol_info->inputs, inputs, ccv_min(sizeof(int) * symbol_info->input_size, sqlite3_column_bytes(exec_symbol_select_stmt, 6))({ typeof (sizeof(int) * symbol_info->input_size) _a = (sizeof
(int) * symbol_info->input_size); typeof (sqlite3_column_bytes
(exec_symbol_select_stmt, 6)) _b = (sqlite3_column_bytes(exec_symbol_select_stmt
, 6)); (_a < _b) ? _a : _b; }));
516		}
517		if (symbol_info->output_size)
518		{
519			const int* const outputs = sqlite3_column_blob(exec_symbol_select_stmt, 7);
520			if (outputs)
521				memcpy(symbol_info->outputs, outputs, ccv_min(sizeof(int) * symbol_info->output_size, sqlite3_column_bytes(exec_symbol_select_stmt, 7))({ typeof (sizeof(int) * symbol_info->output_size) _a = (sizeof
(int) * symbol_info->output_size); typeof (sqlite3_column_bytes
(exec_symbol_select_stmt, 7)) _b = (sqlite3_column_bytes(exec_symbol_select_stmt
, 7)); (_a < _b) ? _a : _b; }));
522		}
523		const int* const outgoings = sqlite3_column_blob(exec_symbol_select_stmt, 8);
524		if (outgoings)
525		{
526			const int count = sqlite3_column_bytes(exec_symbol_select_stmt, 8) / sizeof(int);
527			symbol_info->outgoings = ccv_array_new(sizeof(int), count, 0);
528			ccv_array_resize(symbol_info->outgoings, count);
529			memcpy(ccv_array_get(symbol_info->outgoings, 0)((void*)(((char*)((symbol_info->outgoings)->data)) + (size_t
)(symbol_info->outgoings)->rsize * (size_t)(0))), outgoings, sizeof(int) * count);
530		}
531		const char* const name = (char*)sqlite3_column_text(exec_symbol_select_stmt, 9);
532		if (name)
533		{
534			const int count = sqlite3_column_bytes(exec_symbol_select_stmt, 9);
535			symbol_info->name = (char*)ccmallocmalloc(sizeof(char) * (count + 1));
536			memcpy(symbol_info->name, name, count);
537			symbol_info->name[count] = 0; // null terminator
538		}
539		symbol_info->cmd.cmd = sqlite3_column_int(exec_symbol_select_stmt, 10);
540		symbol_info->cmd.backend = sqlite3_column_int(exec_symbol_select_stmt, 11);
541		symbol_info->cmd.algorithm = sqlite3_column_int(exec_symbol_select_stmt, 12);
542		const void* const cmd_info = sqlite3_column_blob(exec_symbol_select_stmt, 13);
543		if (cmd_info)
544			memcpy(&symbol_info->cmd.info, cmd_info, ccv_min(sizeof(symbol_info->cmd.info), sqlite3_column_bytes(exec_symbol_select_stmt, 13))({ typeof (sizeof(symbol_info->cmd.info)) _a = (sizeof(symbol_info
->cmd.info)); typeof (sqlite3_column_bytes(exec_symbol_select_stmt
, 13)) _b = (sqlite3_column_bytes(exec_symbol_select_stmt, 13
)); (_a < _b) ? _a : _b; }));
545		const void* const hint = sqlite3_column_blob(exec_symbol_select_stmt, 14);
546		if (hint)
547			memcpy(&symbol_info->hint, hint, ccv_min(sizeof(symbol_info->hint), sqlite3_column_bytes(exec_symbol_select_stmt, 14))({ typeof (sizeof(symbol_info->hint)) _a = (sizeof(symbol_info
->hint)); typeof (sqlite3_column_bytes(exec_symbol_select_stmt
, 14)) _b = (sqlite3_column_bytes(exec_symbol_select_stmt, 14
)); (_a < _b) ? _a : _b; }));
548		if (symbol_info->graph_ref_size)
549		{
550			const int* const graph_ref = sqlite3_column_blob(exec_symbol_select_stmt, 15);
551			if (symbol_info->graph_ref_size > sizeof(symbol_info->_inline_graph_ref) / sizeof(symbol_info->_inline_graph_ref[0]))
552				symbol_info->_heap_graph_ref = (int*)cccalloccalloc(symbol_info->graph_ref_size, sizeof(int));
553			if (graph_ref)
554				memcpy(CCV_NNC_GRAPH_REF(symbol_info)((symbol_info)->_heap_graph_ref ? (symbol_info)->_heap_graph_ref
 : (symbol_info)->_inline_graph_ref), graph_ref, ccv_min(sizeof(int) * symbol_info->graph_ref_size, sqlite3_column_bytes(exec_symbol_select_stmt, 15))({ typeof (sizeof(int) * symbol_info->graph_ref_size) _a =
 (sizeof(int) * symbol_info->graph_ref_size); typeof (sqlite3_column_bytes
(exec_symbol_select_stmt, 15)) _b = (sqlite3_column_bytes(exec_symbol_select_stmt
, 15)); (_a < _b) ? _a : _b; }));
555		}
556		if (symbol_info->flags & CCV_NNC_GRAPH_EXEC_CASE_OF)
557		{
558			symbol_info->case_of.flags = sqlite3_column_int(exec_symbol_select_stmt, 17);
559			symbol_info->case_of.argument.offset = sqlite3_column_int(exec_symbol_select_stmt, 18);
560			symbol_info->case_of.argument.size = sqlite3_column_int(exec_symbol_select_stmt, 19);
561		} else if (symbol_info->flags & CCV_NNC_GRAPH_EXEC_P_WHILE) {
562			symbol_info->p_while.input_size = sqlite3_column_int(exec_symbol_select_stmt, 21);
563			if (symbol_info->p_while.input_size)
564			{
565				symbol_info->p_while.inputs = (int*)cccalloccalloc(symbol_info->p_while.input_size, sizeof(int));
566				const int* const inputs = sqlite3_column_blob(exec_symbol_select_stmt, 22);
567				if (inputs)
568					memcpy(symbol_info->p_while.inputs, inputs, ccv_min(sizeof(int) * symbol_info->p_while.input_size, sqlite3_column_bytes(exec_symbol_select_stmt, 22))({ typeof (sizeof(int) * symbol_info->p_while.input_size) _a
 = (sizeof(int) * symbol_info->p_while.input_size); typeof
 (sqlite3_column_bytes(exec_symbol_select_stmt, 22)) _b = (sqlite3_column_bytes
(exec_symbol_select_stmt, 22)); (_a < _b) ? _a : _b; }));
569			}
570		}
571		if (CCV_NNC_GRAPH_EXEC_IS_DEAD(symbol_info->flags)((symbol_info->flags) & CCV_NNC_GRAPH_EXEC_DEAD) && graph->reuse.exec < 0)
572			graph->reuse.exec = i;
573	}
574	sqlite3_reset(exec_symbol_select_stmt);
575	sqlite3_clear_bindings(exec_symbol_select_stmt);
576}
577 
578static void _ccv_nnc_symbolic_graph_rewire(const ccv_array_t* const repo, ccv_nnc_symbolic_graph_t* const graph)
579{
580	if (graph->p && CCV_NNC_IS_SYMBOLIC_GRAPH_POS(graph->p)((uintptr_t)(graph->p) & 1))
581		graph->p = _ccv_nnc_symbolic_graph_get(repo, graph->p);
582	if (graph->pair && CCV_NNC_IS_SYMBOLIC_GRAPH_POS(graph->pair)((uintptr_t)(graph->pair) & 1))
583		graph->pair = _ccv_nnc_symbolic_graph_get(repo, graph->pair);
584	int i;
585	if (graph->sub_graphs)
586		for (i = 0; i < graph->sub_graphs->rnum; i++)
587		{
588			ccv_nnc_symbolic_graph_t* const sub_graph = *(ccv_nnc_symbolic_graph_t**)ccv_array_get(graph->sub_graphs, i)((void*)(((char*)((graph->sub_graphs)->data)) + (size_t
)(graph->sub_graphs)->rsize * (size_t)(i)));
589			if (sub_graph && CCV_NNC_IS_SYMBOLIC_GRAPH_POS(sub_graph)((uintptr_t)(sub_graph) & 1))
590				*(ccv_nnc_symbolic_graph_t**)ccv_array_get(graph->sub_graphs, i)((void*)(((char*)((graph->sub_graphs)->data)) + (size_t
)(graph->sub_graphs)->rsize * (size_t)(i))) = _ccv_nnc_symbolic_graph_get(repo, sub_graph);
591		}
592}
593 
594void ccv_nnc_symbolic_graph_read(const char* const fn, ccv_nnc_symbolic_graph_t** const graph_ref, ccv_nnc_tensor_bind_t** const tensor_binds_ref, int* const tensor_bind_size_ref)
595{
596	sqlite3* conn = 0;
597	if (SQLITE_OK0 != sqlite3_open(fn, &conn))
1
Assuming the condition is false→
2
←
Taking false branch→
598		return;
599	ccv_array_t* const repo = ccv_array_new(sizeof(ccv_nnc_symbolic_graph_t*), 1, 0);
600	const char graph_select_qs[] =
601		"SELECT graph, tensor_symbol_size, exec_symbol_size, sources, destinations, sub_graphs, pair, p, p_idx, "
602		"exec_idx, breakpoint_size, breakpoints, backward_tensor_symbol_size, "
603		"backward_tensor_symbol_idx, backward_exec_symbol_size, backward_exec_symbol_idx, "
604		"parallel_count, parallel_tensor_symbol_size, parallel_tensor_symbol_idx, "
605		"parallel_exec_symbol_size, parallel_exec_symbol_idx FROM graph ORDER BY graph";
606	sqlite3_stmt* graph_select_stmt = 0;
607	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, graph_select_qs, sizeof(graph_select_qs), &graph_select_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, graph_select_qs
, sizeof(graph_select_qs), &graph_select_stmt, 0)) ? 1 : 0
), __extension__ ({ if (0 == sqlite3_prepare_v2(conn, graph_select_qs
, sizeof(graph_select_qs), &graph_select_stmt, 0)) ; else
 __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, graph_select_qs, sizeof(graph_select_qs), &graph_select_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 607, __extension__ __PRETTY_FUNCTION__
); }));
3
←
Assuming the condition is true→
4
←
Taking true branch→
608	sqlite3_stmt* tensor_symbol_select_stmt = 0;
609	const char tensor_symbol_select_qs[] =
610		"SELECT id, assign_ref, r_assign_ref, bypass_ref, r_bypass_ref, p_ref, alias_ref, pair_ref, flags, ofs, stride, "
611		"s_ref, name, type, format, datatype, dim FROM tensor_symbol WHERE graph=$graph ORDER BY id";
612	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, tensor_symbol_select_qs, sizeof(tensor_symbol_select_qs), &tensor_symbol_select_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, tensor_symbol_select_qs
, sizeof(tensor_symbol_select_qs), &tensor_symbol_select_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, tensor_symbol_select_qs, sizeof(tensor_symbol_select_qs
), &tensor_symbol_select_stmt, 0)) ; else __assert_fail (
"SQLITE_OK == sqlite3_prepare_v2(conn, tensor_symbol_select_qs, sizeof(tensor_symbol_select_qs), &tensor_symbol_select_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 612, __extension__ __PRETTY_FUNCTION__
); }));
5
←
Assuming the condition is true→
6
←
Taking true branch→
613	const char exec_symbol_select_qs[] =
614		"SELECT id, input_size, output_size, graph_ref_size, flags, pair_ref, inputs, outputs, outgoings, "
615		"name, cmd_cmd, cmd_backend, cmd_algorithm, cmd_info, hint, graph_ref, case_of_expr, case_of_flags, "
616		"case_of_argument_offset, case_of_argument_size, p_while_expr, p_while_input_size, p_while_inputs "
617		"FROM graph_exec_symbol WHERE graph=$graph ORDER BY id";
618	sqlite3_stmt* exec_symbol_select_stmt = 0;
619	SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, exec_symbol_select_qs, sizeof(exec_symbol_select_qs), &exec_symbol_select_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, exec_symbol_select_qs
, sizeof(exec_symbol_select_qs), &exec_symbol_select_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, exec_symbol_select_qs, sizeof(exec_symbol_select_qs), &
exec_symbol_select_stmt, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, exec_symbol_select_qs, sizeof(exec_symbol_select_qs), &exec_symbol_select_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 619, __extension__ __PRETTY_FUNCTION__
); }));
7
←
Assuming the condition is true→
8
←
Taking true branch→
620	while (SQLITE_ROW100 == sqlite3_step(graph_select_stmt))
9
←
Assuming the condition is false→
10
←
Loop condition is false. Execution continues on line 628→
621	{
622		ccv_nnc_symbolic_graph_t* const graph = ccv_nnc_symbolic_graph_new();
623		const int graph_idx = sqlite3_column_int(graph_select_stmt, 0);
624		assert(graph_idx == repo->rnum)((void) sizeof ((graph_idx == repo->rnum) ? 1 : 0), __extension__
 ({ if (graph_idx == repo->rnum) ; else __assert_fail ("graph_idx == repo->rnum"
, "ccv_nnc_symbolic_graph_io.c", 624, __extension__ __PRETTY_FUNCTION__
); }));
625		ccv_array_push(repo, &graph);
626		_ccv_nnc_symbolic_graph_read(graph_idx, graph_select_stmt, tensor_symbol_select_stmt, exec_symbol_select_stmt, graph);
627	}
628	int i;
629	for (i = 0; i < repo->rnum; i++)
11
←
Assuming 'i' is >= field 'rnum'→
630		_ccv_nnc_symbolic_graph_rewire(repo, *(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, i)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(i))));
631	*graph_ref = (repo->rnum11.1
Field 'rnum' is <= 0
 > 0) ? *(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, 0)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(0))) : 0;
12
←
'?' condition is false→
632	assert((tensor_bind_size_ref && tensor_binds_ref) || (!tensor_bind_size_ref && !tensor_binds_ref))((void) sizeof (((tensor_bind_size_ref && tensor_binds_ref
) || (!tensor_bind_size_ref && !tensor_binds_ref)) ? 1
 : 0), __extension__ ({ if ((tensor_bind_size_ref && tensor_binds_ref
) || (!tensor_bind_size_ref && !tensor_binds_ref)) ; else
 __assert_fail ("(tensor_bind_size_ref && tensor_binds_ref) || (!tensor_bind_size_ref && !tensor_binds_ref)"
, "ccv_nnc_symbolic_graph_io.c", 632, __extension__ __PRETTY_FUNCTION__
); }));
13
←
Assuming 'tensor_bind_size_ref' is non-null→
14
←
Assuming 'tensor_binds_ref' is non-null→
633	if (tensor_bind_size_ref14.1
'tensor_bind_size_ref' is non-null
 && tensor_binds_ref14.2
'tensor_binds_ref' is non-null
)
15
←
Taking true branch→
634	{
635		const char tensor_bind_count_qs[] =
636			"SELECT COUNT(*) FROM tensor_bind";
637		sqlite3_stmt* tensor_bind_count_stmt = 0;
638		SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_count_qs, sizeof(tensor_bind_count_qs), &tensor_bind_count_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, tensor_bind_count_qs
, sizeof(tensor_bind_count_qs), &tensor_bind_count_stmt, 0
)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(conn
, tensor_bind_count_qs, sizeof(tensor_bind_count_qs), &tensor_bind_count_stmt
, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_count_qs, sizeof(tensor_bind_count_qs), &tensor_bind_count_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 638, __extension__ __PRETTY_FUNCTION__
); }));
16
←
Assuming the condition is true→
17
←
Taking true branch→
639		sqlite3_step(tensor_bind_count_stmt);
640		const int tensor_bind_size = *tensor_bind_size_ref = sqlite3_column_int(tensor_bind_count_stmt, 0);
641		sqlite3_finalize(tensor_bind_count_stmt);
642		// Respect the insert order (rowid).
643		if (!tensor_bind_size)
18
←
Assuming 'tensor_bind_size' is not equal to 0→
19
←
Taking false branch→
644			*tensor_binds_ref = 0;
645		else {
646			const char tensor_bind_select_qs[] =
647				"SELECT id, graph, type, format, datatype, dim, data FROM tensor_bind";
648			sqlite3_stmt* tensor_bind_select_stmt = 0;
649			ccv_nnc_tensor_bind_t* const tensor_binds = *tensor_binds_ref = (ccv_nnc_tensor_bind_t*)ccmallocmalloc(sizeof(ccv_nnc_tensor_bind_t) * tensor_bind_size);
650			SQLITE_ENFORCE(SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_select_qs, sizeof(tensor_bind_select_qs), &tensor_bind_select_stmt, 0))((void) sizeof ((0 == sqlite3_prepare_v2(conn, tensor_bind_select_qs
, sizeof(tensor_bind_select_qs), &tensor_bind_select_stmt
, 0)) ? 1 : 0), __extension__ ({ if (0 == sqlite3_prepare_v2(
conn, tensor_bind_select_qs, sizeof(tensor_bind_select_qs), &
tensor_bind_select_stmt, 0)) ; else __assert_fail ("SQLITE_OK == sqlite3_prepare_v2(conn, tensor_bind_select_qs, sizeof(tensor_bind_select_qs), &tensor_bind_select_stmt, 0)"
, "ccv_nnc_symbolic_graph_io.c", 650, __extension__ __PRETTY_FUNCTION__
); }));
20
←
Assuming the condition is true→
21
←
Taking true branch→
651			for (i = 0; SQLITE_ROW100 == sqlite3_step(tensor_bind_select_stmt); i++)
22
←
Assuming the condition is true→
23
←
Loop condition is true.  Entering loop body→
652			{
653				assert(i < tensor_bind_size)((void) sizeof ((i < tensor_bind_size) ? 1 : 0), __extension__
 ({ if (i < tensor_bind_size) ; else __assert_fail ("i < tensor_bind_size"
, "ccv_nnc_symbolic_graph_io.c", 653, __extension__ __PRETTY_FUNCTION__
); }));
24
←
Assuming 'i' is < 'tensor_bind_size'→
25
←
Taking true branch→
654				tensor_binds[i].symbol.d = sqlite3_column_int(tensor_bind_select_stmt, 0);
655				const int graph_idx = sqlite3_column_int(tensor_bind_select_stmt, 1);
656				assert(graph_idx < repo->rnum)((void) sizeof ((graph_idx < repo->rnum) ? 1 : 0), __extension__
 ({ if (graph_idx < repo->rnum) ; else __assert_fail ("graph_idx < repo->rnum"
, "ccv_nnc_symbolic_graph_io.c", 656, __extension__ __PRETTY_FUNCTION__
); }));
26
←
Assuming 'graph_idx' is < field 'rnum'→
27
←
Taking true branch→
657				tensor_binds[i].symbol.graph = (graph_idx >= 0) ? *(ccv_nnc_symbolic_graph_t**)ccv_array_get(repo, graph_idx)((void*)(((char*)((repo)->data)) + (size_t)(repo)->rsize
 * (size_t)(graph_idx))) : 0;
28
←
Assuming 'graph_idx' is < 0→
29
←
'?' condition is false→
658				ccv_nnc_tensor_param_t info;
30
←
'info' initialized here→
659				info.type = sqlite3_column_int(tensor_bind_select_stmt, 2);
660				info.format = sqlite3_column_int(tensor_bind_select_stmt, 3);
661				info.datatype = sqlite3_column_int(tensor_bind_select_stmt, 4);
662				const int* const dim = sqlite3_column_blob(tensor_bind_select_stmt, 5);
663				memset(info.dim, 0, sizeof(info.dim));
664				if (dim)
31
←
Assuming 'dim' is null→
32
←
Taking false branch→
665					memcpy(info.dim, dim, ccv_min(sizeof(info.dim), sqlite3_column_bytes(tensor_bind_select_stmt, 5))({ typeof (sizeof(info.dim)) _a = (sizeof(info.dim)); typeof (
sqlite3_column_bytes(tensor_bind_select_stmt, 5)) _b = (sqlite3_column_bytes
(tensor_bind_select_stmt, 5)); (_a < _b) ? _a : _b; }));
666				const void* const data = sqlite3_column_blob(tensor_bind_select_stmt, 6);
667				if (!data)
33
←
Assuming 'data' is non-null→
34
←
Taking false branch→
668					tensor_binds[i].tensor = 0;
669				else {
670					tensor_binds[i].tensor = ccv_nnc_tensor_new(0, info, 0);
35
←
Passed-by-value struct argument contains uninitialized data (e.g., field: 'reserved')
671					size_t data_size = ccv_nnc_tensor_data_size(info);
672#ifdef HAVE_CUDA1
673					if (CCV_TENSOR_GET_MEMORY(info.type)((info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY)
674						cumemcpy(tensor_binds[i].tensor->data.u8, info.type, data, CCV_TENSOR_CPU_MEMORY, ccv_min(data_size, sqlite3_column_bytes(tensor_bind_select_stmt, 6))({ typeof (data_size) _a = (data_size); typeof (sqlite3_column_bytes
(tensor_bind_select_stmt, 6)) _b = (sqlite3_column_bytes(tensor_bind_select_stmt
, 6)); (_a < _b) ? _a : _b; }));
675					else
676						memcpy(tensor_binds[i].tensor->data.u8, data, ccv_min(data_size, sqlite3_column_bytes(tensor_bind_select_stmt, 6))({ typeof (data_size) _a = (data_size); typeof (sqlite3_column_bytes
(tensor_bind_select_stmt, 6)) _b = (sqlite3_column_bytes(tensor_bind_select_stmt
, 6)); (_a < _b) ? _a : _b; }));
677#else
678					memcpy(tensor_binds[i].tensor->data.u8, data, ccv_min(data_size, sqlite3_column_bytes(tensor_bind_select_stmt, 6))({ typeof (data_size) _a = (data_size); typeof (sqlite3_column_bytes
(tensor_bind_select_stmt, 6)) _b = (sqlite3_column_bytes(tensor_bind_select_stmt
, 6)); (_a < _b) ? _a : _b; }));
679#endif
680				}
681			}
682			for (; i < tensor_bind_size; i++)
683			{
684				tensor_binds[i].symbol.d = CCV_NNC_NO_TENSOR_SYMBOL;
685				tensor_binds[i].symbol.graph = 0;
686				tensor_binds[i].tensor = 0;
687			}
688			sqlite3_finalize(tensor_bind_select_stmt);
689		}
690	}
691	ccv_array_free(repo);
692	sqlite3_finalize(graph_select_stmt);
693	sqlite3_finalize(tensor_symbol_select_stmt);
694	sqlite3_finalize(exec_symbol_select_stmt);
695	sqlite3_close(conn);
696}