Rob Herring | acfe84f | 2019-06-20 15:19:38 -0600 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005. |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #include "dtc.h" |
Jon Loeliger | e45e6fd | 2007-03-23 15:18:41 -0500 | [diff] [blame] | 7 | #include "srcpos.h" |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 8 | |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 9 | extern FILE *yyin; |
| 10 | extern int yyparse(void); |
Horst Kronstorfer | a6e6c60 | 2012-02-07 10:02:53 +0100 | [diff] [blame] | 11 | extern YYLTYPE yylloc; |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 12 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 13 | struct dt_info *parser_output; |
David Gibson | 1762537 | 2013-10-28 21:06:53 +1100 | [diff] [blame] | 14 | bool treesource_error; |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 15 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 16 | struct dt_info *dt_from_source(const char *fname) |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 17 | { |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 18 | parser_output = NULL; |
David Gibson | 1762537 | 2013-10-28 21:06:53 +1100 | [diff] [blame] | 19 | treesource_error = false; |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 20 | |
David Gibson | d68cb36 | 2009-12-08 14:24:42 +1100 | [diff] [blame] | 21 | srcfile_push(fname); |
| 22 | yyin = current_srcfile->f; |
Horst Kronstorfer | a6e6c60 | 2012-02-07 10:02:53 +0100 | [diff] [blame] | 23 | yylloc.file = current_srcfile; |
Jon Loeliger | e45e6fd | 2007-03-23 15:18:41 -0500 | [diff] [blame] | 24 | |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 25 | if (yyparse() != 0) |
David Gibson | 35aa1a2 | 2008-05-16 13:21:51 +1000 | [diff] [blame] | 26 | die("Unable to parse input tree\n"); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 27 | |
David Gibson | 35aa1a2 | 2008-05-16 13:21:51 +1000 | [diff] [blame] | 28 | if (treesource_error) |
| 29 | die("Syntax error parsing input tree\n"); |
| 30 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 31 | return parser_output; |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 32 | } |
| 33 | |
| 34 | static void write_prefix(FILE *f, int level) |
| 35 | { |
| 36 | int i; |
| 37 | |
| 38 | for (i = 0; i < level; i++) |
| 39 | fputc('\t', f); |
| 40 | } |
| 41 | |
David Gibson | 1762537 | 2013-10-28 21:06:53 +1100 | [diff] [blame] | 42 | static bool isstring(char c) |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 43 | { |
Serge Lamikhov-Center | 17119ab | 2013-12-25 15:26:03 +1100 | [diff] [blame] | 44 | return (isprint((unsigned char)c) |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 45 | || (c == '\0') |
| 46 | || strchr("\a\b\t\n\v\f\r", c)); |
| 47 | } |
| 48 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 49 | static void write_propval_string(FILE *f, const char *s, size_t len) |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 50 | { |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 51 | const char *end = s + len - 1; |
Rob Herring | 522d81d | 2018-09-26 14:27:08 -0500 | [diff] [blame] | 52 | |
| 53 | if (!len) |
| 54 | return; |
| 55 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 56 | assert(*end == '\0'); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 57 | |
David Gibson | c623fe5 | 2009-09-09 14:38:30 +1000 | [diff] [blame] | 58 | fprintf(f, "\""); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 59 | while (s < end) { |
| 60 | char c = *s++; |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 61 | switch (c) { |
| 62 | case '\a': |
| 63 | fprintf(f, "\\a"); |
| 64 | break; |
| 65 | case '\b': |
| 66 | fprintf(f, "\\b"); |
| 67 | break; |
| 68 | case '\t': |
| 69 | fprintf(f, "\\t"); |
| 70 | break; |
| 71 | case '\n': |
| 72 | fprintf(f, "\\n"); |
| 73 | break; |
| 74 | case '\v': |
| 75 | fprintf(f, "\\v"); |
| 76 | break; |
| 77 | case '\f': |
| 78 | fprintf(f, "\\f"); |
| 79 | break; |
| 80 | case '\r': |
| 81 | fprintf(f, "\\r"); |
| 82 | break; |
| 83 | case '\\': |
| 84 | fprintf(f, "\\\\"); |
| 85 | break; |
| 86 | case '\"': |
| 87 | fprintf(f, "\\\""); |
| 88 | break; |
| 89 | case '\0': |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 90 | fprintf(f, "\\0"); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 91 | break; |
| 92 | default: |
Serge Lamikhov-Center | 17119ab | 2013-12-25 15:26:03 +1100 | [diff] [blame] | 93 | if (isprint((unsigned char)c)) |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 94 | fprintf(f, "%c", c); |
| 95 | else |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 96 | fprintf(f, "\\x%02"PRIx8, c); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 97 | } |
| 98 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 99 | fprintf(f, "\""); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 100 | } |
| 101 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 102 | static void write_propval_int(FILE *f, const char *p, size_t len, size_t width) |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 103 | { |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 104 | const char *end = p + len; |
| 105 | assert(len % width == 0); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 106 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 107 | for (; p < end; p += width) { |
| 108 | switch (width) { |
| 109 | case 1: |
Rob Herring | d448f9a | 2018-09-14 13:39:06 -0500 | [diff] [blame] | 110 | fprintf(f, "%02"PRIx8, *(const uint8_t*)p); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 111 | break; |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 112 | case 2: |
David Gibson | b28464a | 2020-04-14 15:02:51 +1000 | [diff] [blame] | 113 | fprintf(f, "0x%02"PRIx16, dtb_ld16(p)); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 114 | break; |
| 115 | case 4: |
David Gibson | b28464a | 2020-04-14 15:02:51 +1000 | [diff] [blame] | 116 | fprintf(f, "0x%02"PRIx32, dtb_ld32(p)); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 117 | break; |
| 118 | case 8: |
David Gibson | b28464a | 2020-04-14 15:02:51 +1000 | [diff] [blame] | 119 | fprintf(f, "0x%02"PRIx64, dtb_ld64(p)); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 120 | break; |
| 121 | } |
Rob Herring | d448f9a | 2018-09-14 13:39:06 -0500 | [diff] [blame] | 122 | if (p + width < end) |
| 123 | fputc(' ', f); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 124 | } |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 125 | } |
| 126 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 127 | static const char *delim_start[] = { |
| 128 | [TYPE_UINT8] = "[", |
| 129 | [TYPE_UINT16] = "/bits/ 16 <", |
| 130 | [TYPE_UINT32] = "<", |
| 131 | [TYPE_UINT64] = "/bits/ 64 <", |
| 132 | [TYPE_STRING] = "", |
| 133 | }; |
| 134 | static const char *delim_end[] = { |
Rob Herring | d448f9a | 2018-09-14 13:39:06 -0500 | [diff] [blame] | 135 | [TYPE_UINT8] = "]", |
| 136 | [TYPE_UINT16] = ">", |
| 137 | [TYPE_UINT32] = ">", |
| 138 | [TYPE_UINT64] = ">", |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 139 | [TYPE_STRING] = "", |
| 140 | }; |
| 141 | |
| 142 | static enum markertype guess_value_type(struct property *prop) |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 143 | { |
| 144 | int len = prop->val.len; |
David Gibson | 92cb9a2 | 2007-12-04 14:26:15 +1100 | [diff] [blame] | 145 | const char *p = prop->val.val; |
David Gibson | dc94177 | 2007-11-22 14:39:23 +1100 | [diff] [blame] | 146 | struct marker *m = prop->val.markers; |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 147 | int nnotstring = 0, nnul = 0; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 148 | int nnotstringlbl = 0, nnotcelllbl = 0; |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 149 | int i; |
| 150 | |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 151 | for (i = 0; i < len; i++) { |
| 152 | if (! isstring(p[i])) |
| 153 | nnotstring++; |
| 154 | if (p[i] == '\0') |
| 155 | nnul++; |
| 156 | } |
| 157 | |
David Gibson | dc94177 | 2007-11-22 14:39:23 +1100 | [diff] [blame] | 158 | for_each_marker_of_type(m, LABEL) { |
| 159 | if ((m->offset > 0) && (prop->val.val[m->offset - 1] != '\0')) |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 160 | nnotstringlbl++; |
David Gibson | dc94177 | 2007-11-22 14:39:23 +1100 | [diff] [blame] | 161 | if ((m->offset % sizeof(cell_t)) != 0) |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 162 | nnotcelllbl++; |
| 163 | } |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 164 | |
Geert Uytterhoeven | 9d7888c | 2020-06-23 11:43:43 +0200 | [diff] [blame] | 165 | if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= (len-nnul)) |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 166 | && (nnotstringlbl == 0)) { |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 167 | return TYPE_STRING; |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 168 | } else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) { |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 169 | return TYPE_UINT32; |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 170 | } |
David Gibson | d3ea6e5 | 2007-11-07 10:22:25 +1100 | [diff] [blame] | 171 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 172 | return TYPE_UINT8; |
| 173 | } |
| 174 | |
| 175 | static void write_propval(FILE *f, struct property *prop) |
| 176 | { |
| 177 | size_t len = prop->val.len; |
| 178 | struct marker *m = prop->val.markers; |
| 179 | struct marker dummy_marker; |
| 180 | enum markertype emit_type = TYPE_NONE; |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 181 | char *srcstr; |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 182 | |
| 183 | if (len == 0) { |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 184 | fprintf(f, ";"); |
| 185 | if (annotate) { |
| 186 | srcstr = srcpos_string_first(prop->srcpos, annotate); |
| 187 | if (srcstr) { |
| 188 | fprintf(f, " /* %s */", srcstr); |
| 189 | free(srcstr); |
| 190 | } |
| 191 | } |
| 192 | fprintf(f, "\n"); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 193 | return; |
| 194 | } |
| 195 | |
Grant Likely | 8c59a97 | 2018-09-14 14:01:09 +0100 | [diff] [blame] | 196 | fprintf(f, " ="); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 197 | |
| 198 | if (!next_type_marker(m)) { |
| 199 | /* data type information missing, need to guess */ |
| 200 | dummy_marker.type = guess_value_type(prop); |
| 201 | dummy_marker.next = prop->val.markers; |
| 202 | dummy_marker.offset = 0; |
| 203 | dummy_marker.ref = NULL; |
| 204 | m = &dummy_marker; |
| 205 | } |
| 206 | |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 207 | for_each_marker(m) { |
Grant Likely | 8c59a97 | 2018-09-14 14:01:09 +0100 | [diff] [blame] | 208 | size_t chunk_len = (m->next ? m->next->offset : len) - m->offset; |
| 209 | size_t data_len = type_marker_length(m) ? : len - m->offset; |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 210 | const char *p = &prop->val.val[m->offset]; |
Pierre-Clément Tosi | ef1978a | 2022-05-30 20:57:34 +0100 | [diff] [blame] | 211 | struct marker *m_phandle; |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 212 | |
Pierre-Clément Tosi | ef1978a | 2022-05-30 20:57:34 +0100 | [diff] [blame] | 213 | if (is_type_marker(m->type)) { |
Grant Likely | 8c59a97 | 2018-09-14 14:01:09 +0100 | [diff] [blame] | 214 | emit_type = m->type; |
| 215 | fprintf(f, " %s", delim_start[emit_type]); |
Rob Herring | da2b691 | 2018-10-10 10:19:30 -0500 | [diff] [blame] | 216 | } else if (m->type == LABEL) |
Grant Likely | 8c59a97 | 2018-09-14 14:01:09 +0100 | [diff] [blame] | 217 | fprintf(f, " %s:", m->ref); |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 218 | |
Pierre-Clément Tosi | ef1978a | 2022-05-30 20:57:34 +0100 | [diff] [blame] | 219 | if (emit_type == TYPE_NONE || chunk_len == 0) |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 220 | continue; |
| 221 | |
| 222 | switch(emit_type) { |
| 223 | case TYPE_UINT16: |
| 224 | write_propval_int(f, p, chunk_len, 2); |
| 225 | break; |
| 226 | case TYPE_UINT32: |
Pierre-Clément Tosi | ef1978a | 2022-05-30 20:57:34 +0100 | [diff] [blame] | 227 | m_phandle = prop->val.markers; |
| 228 | for_each_marker_of_type(m_phandle, REF_PHANDLE) |
| 229 | if (m->offset == m_phandle->offset) |
| 230 | break; |
| 231 | |
| 232 | if (m_phandle) { |
| 233 | if (m_phandle->ref[0] == '/') |
| 234 | fprintf(f, "&{%s}", m_phandle->ref); |
| 235 | else |
| 236 | fprintf(f, "&%s", m_phandle->ref); |
| 237 | if (chunk_len > 4) { |
| 238 | fputc(' ', f); |
| 239 | write_propval_int(f, p + 4, chunk_len - 4, 4); |
| 240 | } |
| 241 | } else { |
| 242 | write_propval_int(f, p, chunk_len, 4); |
| 243 | } |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 244 | break; |
| 245 | case TYPE_UINT64: |
| 246 | write_propval_int(f, p, chunk_len, 8); |
| 247 | break; |
| 248 | case TYPE_STRING: |
| 249 | write_propval_string(f, p, chunk_len); |
| 250 | break; |
| 251 | default: |
| 252 | write_propval_int(f, p, chunk_len, 1); |
| 253 | } |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 254 | |
Grant Likely | 8c59a97 | 2018-09-14 14:01:09 +0100 | [diff] [blame] | 255 | if (chunk_len == data_len) { |
| 256 | size_t pos = m->offset + chunk_len; |
| 257 | fprintf(f, pos == len ? "%s" : "%s,", |
| 258 | delim_end[emit_type] ? : ""); |
| 259 | emit_type = TYPE_NONE; |
| 260 | } |
Grant Likely | 32b9c61 | 2018-06-28 15:37:01 -0600 | [diff] [blame] | 261 | } |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 262 | fprintf(f, ";"); |
| 263 | if (annotate) { |
| 264 | srcstr = srcpos_string_first(prop->srcpos, annotate); |
| 265 | if (srcstr) { |
| 266 | fprintf(f, " /* %s */", srcstr); |
| 267 | free(srcstr); |
| 268 | } |
| 269 | } |
| 270 | fprintf(f, "\n"); |
David Gibson | 5a98ddd | 2007-10-17 12:39:10 +1000 | [diff] [blame] | 271 | } |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 272 | |
David Gibson | 230f253 | 2005-08-29 12:48:02 +1000 | [diff] [blame] | 273 | static void write_tree_source_node(FILE *f, struct node *tree, int level) |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 274 | { |
| 275 | struct property *prop; |
| 276 | struct node *child; |
David Gibson | 05898c6 | 2010-02-24 18:22:17 +1100 | [diff] [blame] | 277 | struct label *l; |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 278 | char *srcstr; |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 279 | |
| 280 | write_prefix(f, level); |
David Gibson | 05898c6 | 2010-02-24 18:22:17 +1100 | [diff] [blame] | 281 | for_each_label(tree->labels, l) |
| 282 | fprintf(f, "%s: ", l->label); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 283 | if (tree->name && (*tree->name)) |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 284 | fprintf(f, "%s {", tree->name); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 285 | else |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 286 | fprintf(f, "/ {"); |
| 287 | |
| 288 | if (annotate) { |
| 289 | srcstr = srcpos_string_first(tree->srcpos, annotate); |
| 290 | if (srcstr) { |
| 291 | fprintf(f, " /* %s */", srcstr); |
| 292 | free(srcstr); |
| 293 | } |
| 294 | } |
| 295 | fprintf(f, "\n"); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 296 | |
| 297 | for_each_property(tree, prop) { |
David Gibson | 02563ad | 2007-11-02 16:10:30 +1100 | [diff] [blame] | 298 | write_prefix(f, level+1); |
David Gibson | 05898c6 | 2010-02-24 18:22:17 +1100 | [diff] [blame] | 299 | for_each_label(prop->labels, l) |
| 300 | fprintf(f, "%s: ", l->label); |
David Gibson | 02563ad | 2007-11-02 16:10:30 +1100 | [diff] [blame] | 301 | fprintf(f, "%s", prop->name); |
David Gibson | ed01ae4 | 2007-11-07 10:21:20 +1100 | [diff] [blame] | 302 | write_propval(f, prop); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 303 | } |
| 304 | for_each_child(tree, child) { |
| 305 | fprintf(f, "\n"); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 306 | write_tree_source_node(f, child, level+1); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 307 | } |
| 308 | write_prefix(f, level); |
Julia Lawall | 5667e7e | 2018-11-16 17:30:00 +0100 | [diff] [blame] | 309 | fprintf(f, "};"); |
| 310 | if (annotate) { |
| 311 | srcstr = srcpos_string_last(tree->srcpos, annotate); |
| 312 | if (srcstr) { |
| 313 | fprintf(f, " /* %s */", srcstr); |
| 314 | free(srcstr); |
| 315 | } |
| 316 | } |
| 317 | fprintf(f, "\n"); |
David Gibson | fc14dad | 2005-06-08 17:18:34 +1000 | [diff] [blame] | 318 | } |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 319 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 320 | void dt_to_source(FILE *f, struct dt_info *dti) |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 321 | { |
David Gibson | f040d95 | 2005-10-24 18:18:38 +1000 | [diff] [blame] | 322 | struct reserve_info *re; |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 323 | |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame] | 324 | fprintf(f, "/dts-v1/;\n\n"); |
| 325 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 326 | for (re = dti->reservelist; re; re = re->next) { |
David Gibson | 05898c6 | 2010-02-24 18:22:17 +1100 | [diff] [blame] | 327 | struct label *l; |
| 328 | |
| 329 | for_each_label(re->labels, l) |
| 330 | fprintf(f, "%s: ", l->label); |
David Gibson | 91967ac | 2007-11-07 11:17:37 +1100 | [diff] [blame] | 331 | fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n", |
David Gibson | 49300f2 | 2017-03-06 12:04:45 +1100 | [diff] [blame] | 332 | (unsigned long long)re->address, |
| 333 | (unsigned long long)re->size); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 334 | } |
| 335 | |
David Gibson | 00fbb86 | 2016-05-31 11:58:42 +1000 | [diff] [blame] | 336 | write_tree_source_node(f, dti->dt, 0); |
David Gibson | f0517db | 2005-07-15 17:14:24 +1000 | [diff] [blame] | 337 | } |