git.gag.com Git - fw/sdcc/blob - src/pic16/device.c

   1 /*-------------------------------------------------------------------------
   2
   3   device.c - Accomodates subtle variations in PIC16 devices
   4
   5    Written By -  Scott Dattalo scott@dattalo.com
   6    Ported to PIC16 By -  Martin Dubuc m.dubuc@rogers.com
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 2, or (at your option) any
  11    later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 -------------------------------------------------------------------------*/
  22
  23
  24 /*
  25         VR - Began writing code to make PIC16 C source files independent from
  26         the header file (created by the inc2h.pl)
  27
  28         - adding maximum RAM memory into PIC_Device structure
  29
  30 */
  31
  32 #include <stdio.h>
  33
  34 #include "common.h"   // Include everything in the SDCC src directory
  35 #include "newalloc.h"
  36
  37
  38 #include "pcode.h"
  39 #include "ralloc.h"
  40 #include "device.h"
  41
  42
  43 static PIC16_device Pics16[] = {
  44 //  {
  45 //    {"p18f242", "18f242", "pic18f242", "f242"},               // aliases
  46 //    0,
  47 //    0x300,                                            // RAMsize
  48 //    0,
  49 //    { 0xf80, 0xfff },       /* PIC18F242 range of SFR's */
  50 //      {
  51 //              /* PIC18F242 configuration words */
  52 //              0x300001,
  53 //              0x30000d,
  54 //              { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
  55 //              { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
  56 //              { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
  57 //              { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
  58 //              { 0x40, 0, 0xff } /* d */ }
  59 //      }
  60 //  },
  61
  62   {
  63     {"p18f242", "18f242", "pic18f242", "f242"},
  64     0,
  65     0x300,      /* 768 */
  66     0x80,
  67     0,
  68     { 0xf80, 0xfff },   /* PIC18F242 range of SFR's */
  69     {
  70     /* PIC18F242 configuration words */
  71       0x300001,
  72       0x30000d,
  73       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
  74       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
  75       { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
  76       { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
  77       { 0x40, 0, 0xff } /* d */  }
  78     }
  79   },
  80   {
  81     {"p18f248", "18f248", "pic18f248", "f248"},
  82     0,
  83     0x300,      /* 768 */
  84     0x60,
  85     0,
  86     { 0xf00, 0xfff },   /* PIC18F248 range of SFR's */
  87     {
  88     /* PIC18F248 configuration words */
  89       0x300001,
  90       0x30000d,
  91       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
  92       { -1, 0, 0xff } /* 4 */  , { -1, 0, 0xff } /* 5 */  , { 0x85, 0, 0xff } /* 6 */ ,
  93       { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
  94       { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
  95       { 0x40, 0, 0xff } /* d */  }
  96     }
  97   },
  98   {
  99     {"p18f252", "18f252", "pic18f252", "f252"},
 100     0,
 101     0x600,      /* 1536 */
 102     0x80,
 103     0,
 104     { 0xf80, 0xfff },   /* PIC18F252 range of SFR's */
 105     {
 106     /* PIC18F252 configuration words */
 107       0x300001,
 108       0x30000d,
 109       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 110       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 111       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 112       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 113       { 0x40, 0, 0xff } /* d */  }
 114     }
 115   },
 116   {
 117     {"p18f258", "18f258", "pic18f258", "f258"},
 118     0,
 119     0x600,      /* 1536 */
 120     0x60,
 121     0,
 122     { 0xf00, 0xfff },   /* PIC18F258 range of SFR's */
 123     {
 124     /* PIC18F258 configuration words */
 125       0x300001,
 126       0x30000d,
 127       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 128       { -1, 0, 0xff } /* 4 */  , { -1, 0, 0xff } /* 5 */  , { 0x85, 0, 0xff } /* 6 */ ,
 129       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 130       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 131       { 0x40, 0, 0xff } /* d */  }
 132     }
 133   },
 134   {
 135     {"p18f442", "18f442", "pic18f442", "f442"},
 136     0,
 137     0x300,      /* 768 */
 138     0x80,
 139     0,
 140     { 0xf80, 0xfff },   /* PIC18F442 range of SFR's */
 141     {
 142     /* PIC18F442 configuration words */
 143       0x300001,
 144       0x30000d,
 145       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 146       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 147       { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 148       { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
 149       { 0x40, 0, 0xff } /* d */  }
 150     }
 151   },
 152   {
 153     {"p18f448", "18f448", "pic18f448", "f448"},
 154     0,
 155     0x300,      /* 768 */
 156     0x60,
 157     0,
 158     { 0xf00, 0xfff },   /* PIC18F448 range of SFR's */
 159     {
 160     /* PIC18F448 configuration words */
 161       0x300001,
 162       0x30000d,
 163       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 164       { -1, 0, 0xff } /* 4 */  , { -1, 0, 0xff } /* 5 */  , { 0x85, 0, 0xff } /* 6 */ ,
 165       { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 166       { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
 167       { 0x40, 0, 0xff } /* d */  }
 168     }
 169   },
 170   {
 171     {"p18f452", "18f452", "pic18f452", "f452"},
 172     0,
 173     0x600,      /* 1536 */
 174     0x80,
 175     0,
 176     { 0xf80, 0xfff },   /* PIC18F452 range of SFR's */
 177     {
 178     /* PIC18F452 configuration words */
 179       0x300001,
 180       0x30000d,
 181       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 182       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 183       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 184       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 185       { 0x40, 0, 0xff } /* d */  }
 186     }
 187   },
 188   {
 189     {"p18f458", "18f458", "pic18f458", "f458"},
 190     0,
 191     0x600,      /* 1536 */
 192     0x60,
 193     0,
 194     { 0xf00, 0xfff },   /* PIC18F458 range of SFR's */
 195     {
 196     /* PIC18F458 configuration words */
 197       0x300001,
 198       0x30000d,
 199       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 200       { -1, 0, 0xff } /* 4 */  , { -1, 0, 0xff } /* 5 */  , { 0x85, 0, 0xff } /* 6 */ ,
 201       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 202       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 203       { 0x40, 0, 0xff } /* d */  }
 204     }
 205   },
 206   {
 207     {"p18f1220", "18f1220", "pic18f1220", "f1220"},
 208     0,
 209     0x100,      /* 256 */
 210     0x80,
 211     0,
 212     { 0xf80, 0xfff },   /* PIC18F1220 range of SFR's */
 213     {
 214     /* PIC18F1220 configuration words */
 215       0x300001,
 216       0x30000d,
 217       { { 0xcf, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x1f, 0, 0xff } /* 3 */ ,
 218       { -1, 0, 0xff } /* 4 */  , { 0x80, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 219       { -1, 0, 0xff } /* 7 */  , { 0x03, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 220       { 0x03, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x03, 0, 0xff } /* c */ ,
 221       { 0x40, 0, 0xff } /* d */  }
 222     }
 223   },
 224   {
 225     {"p18f6520", "18f6520", "pic18f6520", "f6520"},
 226     0,
 227     0x800,      /* 2048 */
 228     0x60,
 229     0,
 230     { 0xf6b, 0xfff },   /* PIC18F6520 range of SFR's */
 231     {
 232     /* PIC18F6520 configuration words */
 233       0x300001,
 234       0x30000d,
 235       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 236       { 0x80, 0, 0xff } /* 4 */ , { 0x88, 0, 0xff } /* 5 */ , { -1, 0, 0xff } /* 6 */  ,
 237       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 238       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 239       { 0x40, 0, 0xff } /* d */  }
 240     }
 241   },
 242   {
 243     {"p18f6620", "18f6620", "pic18f6620", "f6620"},
 244     0,
 245     0xf00,      /* 3840 */
 246     0x60,
 247     0,
 248     { 0xf6b, 0xfff },   /* PIC18F6620 range of SFR's */
 249     {
 250     /* PIC18F6620 configuration words */
 251       0x300001,
 252       0x30000d,
 253       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 254       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 255       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 256       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 257       { 0x40, 0, 0xff } /* d */  }
 258     }
 259   },
 260   {
 261     {"p18f6680", "18f6680", "pic18f6680", "f6680"},
 262     0,
 263     0xf00,      /* 3840 */
 264     0x60,
 265     0,
 266     { 0xf00, 0xfff },   /* PIC18F6680 range of SFR's */
 267     {
 268     /* PIC18F6680 configuration words */
 269       0x300001,
 270       0x30000d,
 271       { { 0x2f, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x1f, 0, 0xff } /* 3 */ ,
 272       { -1, 0, 0xff } /* 4 */  , { 0x83, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 273       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 274       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 275       { 0x40, 0, 0xff } /* d */  }
 276     }
 277   },
 278   {
 279     {"p18f6720", "18f6720", "pic18f6720", "f6720"},
 280     0,
 281     0xf00,      /* 3840 */
 282     0x60,
 283     0,
 284     { 0xf6b, 0xfff },   /* PIC18F6720 range of SFR's */
 285     {
 286     /* PIC18F6720 configuration words */
 287       0x300001,
 288       0x30000d,
 289       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 290       { -1, 0, 0xff } /* 4 */  , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 291       { -1, 0, 0xff } /* 7 */  , { 0xff, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 292       { 0xff, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0xff, 0, 0xff } /* c */ ,
 293       { 0x40, 0, 0xff } /* d */  }
 294     }
 295   },
 296   {
 297     {"p18f8520", "18f8520", "pic18f8520", "f8520"},
 298     0,
 299     0x800,      /* 2048 */
 300     0x60,
 301     1,
 302     { 0xf6b, 0xfff },   /* PIC18F8520 range of SFR's */
 303     {
 304     /* PIC18F8520 configuration words */
 305       0x300001,
 306       0x30000d,
 307       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 308       { 0x83, 0, 0xff } /* 4 */ , { 0x88, 0, 0xff } /* 5 */ , { -1, 0, 0xff } /* 6 */  ,
 309       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 310       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 311       { 0x40, 0, 0xff } /* d */  }
 312     }
 313   },
 314   {
 315     {"p18f8620", "18f8620", "pic18f8620", "f8620"},
 316     0,
 317     0xf00,      /* 3840 */
 318     0x60,
 319     1,
 320     { 0xf6b, 0xfff },   /* PIC18F8620 range of SFR's */
 321     {
 322     /* PIC18F8620 configuration words */
 323       0x300001,
 324       0x30000d,
 325       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 326       { 0x83, 0, 0xff } /* 4 */ , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 327       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 328       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 329       { 0x40, 0, 0xff } /* d */  }
 330     }
 331   },
 332   {
 333     {"p18f8680", "18f8680", "pic18f8680", "f8680"},
 334     0,
 335     0xf00,      /* 3840 */
 336     0x60,
 337     0,
 338     { 0xf00, 0xfff },   /* PIC18F8680 range of SFR's */
 339     {
 340     /* PIC18F8680 configuration words */
 341       0x300001,
 342       0x30000d,
 343       { { 0x2f, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x1f, 0, 0xff } /* 3 */ ,
 344       { 0x83, 0, 0xff } /* 4 */ , { 0x83, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 345       { -1, 0, 0xff } /* 7 */  , { 0x0f, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 346       { 0x0f, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
 347       { 0x40, 0, 0xff } /* d */  }
 348     }
 349   },
 350   {
 351     {"p18f8720", "18f8720", "pic18f8720", "f8720"},
 352     0,
 353     0xf00,      /* 3840 */
 354     0x60,
 355     1,
 356     { 0xf6b, 0xfff },   /* PIC18F8720 range of SFR's */
 357     {
 358     /* PIC18F8720 configuration words */
 359       0x300001,
 360       0x30000d,
 361       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ , { 0x0f, 0, 0xff } /* 3 */ ,
 362       { 0x83, 0, 0xff } /* 4 */ , { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
 363       { -1, 0, 0xff } /* 7 */  , { 0xff, 0, 0xff } /* 8 */ , { 0xc0, 0, 0xff } /* 9 */ ,
 364       { 0xff, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0xff, 0, 0xff } /* c */ ,
 365       { 0x40, 0, 0xff } /* d */  }
 366     }
 367   },
 368
 369 };
 370
 371 static int num_of_supported_PICS = sizeof(Pics16)/sizeof(PIC16_device);
 372
 373 #define DEFAULT_PIC "452"
 374
 375 PIC16_device *pic16=NULL;
 376 unsigned int stackPos = 0;
 377
 378 extern regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alias, operand *refop);
 379
 380 void pic16_setMaxRAM(int size)
 381 {
 382         pic16->maxRAMaddress = size;
 383         stackPos = pic16->RAMsize-1;
 384
 385         if (pic16->maxRAMaddress < 0) {
 386                 fprintf(stderr, "invalid \"#pragma maxram 0x%x\" setting\n",
 387                         pic16->maxRAMaddress);
 388           return;
 389         }
 390 }
 391
 392 extern char *iComments2;
 393
 394 void pic16_dump_equates(FILE *of, set *equs)
 395 {
 396   regs *r;
 397
 398         r = setFirstItem(equs);
 399         if(!r)return;
 400
 401         fprintf(of, "%s", iComments2);
 402         fprintf(of, ";\tEquates to used internal registers\n");
 403         fprintf(of, "%s", iComments2);
 404
 405         for(; r; r = setNextItem(equs)) {
 406                 fprintf(of, "%s\tequ\t0x%02x\n", r->name, r->address);
 407         }
 408 }
 409
 410
 411 int regCompare(const void *a, const void *b)
 412 {
 413   const regs *const *i = a;
 414   const regs *const *j = b;
 415
 416         /* sort primarily by the address */
 417         if( (*i)->address > (*j)->address)return 1;
 418         if( (*i)->address < (*j)->address)return -1;
 419
 420         /* and secondarily by size */
 421         /* register size sorting may have strange results use with care */
 422         if( (*i)->size > (*j)->size)return 1;
 423         if( (*i)->size < (*j)->size)return -1;
 424
 425         /* finally if in same address and same size sort by name */
 426         return (strcmp( (*i)->name, (*j)->name));
 427
 428   return 0;
 429 }
 430
 431 int symCompare(const void *a, const void *b)
 432 {
 433   const symbol *const *i = a;
 434   const symbol *const *j = b;
 435
 436         /* sort primarily by the address */
 437         if( SPEC_ADDR((*i)->etype) > SPEC_ADDR((*j)->etype))return 1;
 438         if( SPEC_ADDR((*i)->etype) < SPEC_ADDR((*j)->etype))return -1;
 439
 440         /* and secondarily by size */
 441         /* register size sorting may have strange results use with care */
 442         if( getSize((*i)->etype) > getSize((*j)->etype))return 1;
 443         if( getSize((*i)->etype) < getSize((*j)->etype))return -1;
 444
 445         /* finally if in same address and same size sort by name */
 446         return (strcmp( (*i)->rname, (*j)->rname));
 447
 448   return 0;
 449 }
 450
 451 void pic16_dump_usection(FILE *of, set *section, int fix)
 452 {
 453   static int abs_usection_no=0;
 454   regs *r, *rprev;
 455   int init_addr, i;
 456   regs **rlist;
 457   regs *r1;
 458
 459         /* put all symbols in an array */
 460         rlist = Safe_calloc(elementsInSet(section), sizeof(regs *));
 461         r = rlist[0]; i = 0;
 462         for(rprev = setFirstItem(section); rprev; rprev = setNextItem(section)) {
 463                 rlist[i] = rprev; i++;
 464         }
 465
 466         if(!i) {
 467                 if(rlist)free(rlist);
 468           return;
 469         }
 470
 471         /* sort symbols according to their address */
 472         qsort(rlist, i  /*elementsInSet(section)*/, sizeof(regs *), regCompare);
 473
 474         if(!fix) {
 475                 fprintf(of, "\n\n\tudata\n");
 476                 for(r = setFirstItem(section); r; r = setNextItem(section)) {
 477                         fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 478                 }
 479         } else {
 480           int j=0;
 481           int deb_addr=0;
 482
 483                 rprev = NULL;
 484                 init_addr = rlist[j]->address;
 485                 deb_addr = init_addr;
 486                 fprintf(of, "\n\nustat_%s_%02d\tudata\t0X%04X\n", moduleName, abs_usection_no++, init_addr);
 487
 488                 for(j=0;j<i;j++) {
 489                         r = rlist[j];
 490                         if(j < i-1)r1 = rlist[j+1]; else r1 = NULL;
 491
 492                         init_addr = r->address;
 493                         deb_addr = init_addr;
 494
 495                         if((rprev && (init_addr > (rprev->address + rprev->size)))) {
 496                                 fprintf(of, "\n\nustat_%s_%02d\tudata\t0X%04X\n", moduleName, abs_usection_no++, init_addr);
 497                         }
 498
 499                         if(r1 && (init_addr == r1->address)) {
 500                                 fprintf(of, "\n%s\tres\t0\n", r->name);
 501                         } else {
 502                                 fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 503                                 deb_addr += r->size;
 504                         }
 505
 506                         rprev = r;
 507                 }
 508         }
 509         free(rlist);
 510 }
 511
 512
 513 /* forward declaration */
 514 void pic16_printIval(symbol * sym, sym_link * type, initList * ilist, char ptype, void *p);
 515
 516 void pic16_dump_isection(FILE *of, set *section, int fix)
 517 {
 518   static int abs_isection_no=0;
 519   symbol *s, *sprev;
 520   int init_addr, i;
 521   symbol **slist;
 522
 523         /* put all symbols in an array */
 524         slist = Safe_calloc(elementsInSet(section), sizeof(symbol *));
 525         s = slist[0]; i = 0;
 526         for(sprev = setFirstItem(section); sprev; sprev = setNextItem(section)) {
 527                 slist[i] = sprev; i++;
 528         }
 529
 530         if(!i) {
 531                 if(slist)free(slist);
 532           return;
 533         }
 534
 535         /* sort symbols according to their address */
 536         qsort(slist, i, sizeof(symbol *), symCompare);
 537
 538         pic16_initDB();
 539
 540         if(!fix) {
 541                 fprintf(of, "\n\n\tidata\n");
 542                 for(s = setFirstItem(section); s; s = setNextItem(section)) {
 543                         fprintf(of, "%s", s->rname);
 544                         pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
 545                         pic16_flushDB('f', (void *)of);
 546                 }
 547         } else {
 548           int j=0;
 549           symbol *s1;
 550
 551                 sprev = NULL;
 552                 init_addr = SPEC_ADDR(slist[j]->etype);
 553                 fprintf(of, "\n\nistat_%s_%02d\tidata\t0X%04X\n", moduleName, abs_isection_no++, init_addr);
 554
 555                 for(j=0;j<i;j++) {
 556                         s = slist[j];
 557                         if(j < i-1)s1 = slist[j+1]; else s1 = NULL;
 558
 559                         init_addr = SPEC_ADDR(s->etype);
 560
 561                         if(sprev && (init_addr > (SPEC_ADDR(sprev->etype) + getSize(sprev->etype)))) {
 562                                 fprintf(of, "\nistat_%s_%02d\tidata\t0X%04X\n", moduleName, abs_isection_no++, init_addr);
 563                         }
 564
 565                         fprintf(of, "%s", s->rname);
 566                         pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
 567                         pic16_flushDB('f', (void *)of);
 568
 569                         sprev = s;
 570                 }
 571         }
 572         free(slist);
 573 }
 574
 575
 576 void pic16_dump_int_registers(FILE *of, set *section)
 577 {
 578   regs *r, *rprev;
 579   int i;
 580   regs **rlist;
 581
 582         /* put all symbols in an array */
 583         rlist = Safe_calloc(elementsInSet(section), sizeof(regs *));
 584         r = rlist[0]; i = 0;
 585         for(rprev = setFirstItem(section); rprev; rprev = setNextItem(section)) {
 586                 rlist[i] = rprev; i++;
 587         }
 588
 589         /* sort symbols according to their address */
 590         qsort(rlist, elementsInSet(section), sizeof(regs *), regCompare);
 591
 592         if(!i) {
 593                 if(rlist)free(rlist);
 594           return;
 595         }
 596
 597         fprintf(of, "\n\n; Internal registers\n");
 598
 599         fprintf(of, "%s\tudata_ovr\t0x0000\n", ".registers");
 600         for(r = setFirstItem(section); r; r = setNextItem(section))
 601                 fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 602
 603         free(rlist);
 604 }
 605
 606
 607 #ifdef WORDS_BIGENDIAN
 608   #define _ENDIAN(x)  (3-x)
 609 #else
 610   #define _ENDIAN(x)  (x)
 611 #endif
 612
 613 #define BYTE_IN_LONG(x,b) ((x>>(8*_ENDIAN(b)))&0xff)
 614
 615
 616 /*-----------------------------------------------------------------*
 617  *  void pic16_list_valid_pics(int ncols, int list_alias)
 618  *
 619  * Print out a formatted list of valid PIC devices
 620  *
 621  * ncols - number of columns in the list.
 622  *
 623  * list_alias - if non-zero, print all of the supported aliases
 624  *              for a device (e.g. F84, 16F84, etc...)
 625  *-----------------------------------------------------------------*/
 626 void pic16_list_valid_pics(int ncols, int list_alias)
 627 {
 628   int col,longest;
 629   int i,j,k,l;
 630
 631   if(list_alias)
 632     list_alias = sizeof(Pics16[0].name) / sizeof(Pics16[0].name[0]);
 633
 634   /* decrement the column number if it's greater than zero */
 635   ncols = (ncols > 1) ? ncols-1 : 4;
 636
 637   /* Find the device with the longest name */
 638   for(i=0,longest=0; i<num_of_supported_PICS; i++) {
 639     for(j=0; j<=list_alias; j++) {
 640       k = strlen(Pics16[i].name[j]);
 641       if(k>longest)
 642         longest = k;
 643     }
 644   }
 645
 646   col = 0;
 647
 648   for(i=0;  i < num_of_supported_PICS; i++) {
 649     j = 0;
 650     do {
 651
 652       fprintf(stderr,"%s", Pics16[i].name[j]);
 653       if(col<ncols) {
 654         l = longest + 2 - strlen(Pics16[i].name[j]);
 655         for(k=0; k<l; k++)
 656           fputc(' ',stderr);
 657
 658         col++;
 659
 660       } else {
 661         fputc('\n',stderr);
 662         col = 0;
 663       }
 664
 665     } while(++j<list_alias);
 666
 667   }
 668   if(col != ncols)
 669     fputc('\n',stderr);
 670
 671 }
 672
 673 /*-----------------------------------------------------------------*
 674  *
 675  *-----------------------------------------------------------------*/
 676 PIC16_device *pic16_find_device(char *name)
 677 {
 678
 679   int i,j;
 680
 681   if(!name)
 682     return NULL;
 683
 684   for(i = 0; i<num_of_supported_PICS; i++) {
 685
 686     for(j=0; j<PROCESSOR_NAMES; j++)
 687       if(!STRCASECMP(Pics16[i].name[j], name) )
 688         return &Pics16[i];
 689   }
 690
 691   /* not found */
 692   return NULL;
 693 }
 694
 695 /*-----------------------------------------------------------------*
 696  *
 697  *-----------------------------------------------------------------*/
 698 void pic16_init_pic(char *pic_type)
 699 {
 700         pic16 = pic16_find_device(pic_type);
 701
 702         if(!pic16) {
 703                 if(pic_type)
 704                         fprintf(stderr, "'%s' was not found.\n", pic_type);
 705                 else
 706                         fprintf(stderr, "No processor has been specified (use -pPROCESSOR_NAME)\n");
 707
 708                 fprintf(stderr,"Valid devices are:\n");
 709
 710                 pic16_list_valid_pics(4,0);
 711                 exit(1);
 712         }
 713
 714 //      printf("PIC processor found and initialized: %s\n", pic_type);
 715         pic16_setMaxRAM( 0xfff  );
 716 }
 717
 718 /*-----------------------------------------------------------------*
 719  *
 720  *-----------------------------------------------------------------*/
 721 int pic16_picIsInitialized(void)
 722 {
 723   if(pic16 && pic16->maxRAMaddress > 0)
 724     return 1;
 725
 726   return 0;
 727
 728 }
 729
 730 /*-----------------------------------------------------------------*
 731  *  char *pic16_processor_base_name(void) - Include file is derived from this.
 732  *-----------------------------------------------------------------*/
 733 char *pic16_processor_base_name(void)
 734 {
 735
 736   if(!pic16)
 737     return NULL;
 738
 739   return pic16->name[0];
 740 }
 741
 742 #define DEBUG_CHECK     0
 743
 744 /*
 745  * return 1 if register wasn't found and added, 0 otherwise
 746  */
 747 int checkAddReg(set **set, regs *reg)
 748 {
 749   regs *tmp;
 750
 751 #if DEBUG_CHECK
 752         fprintf(stderr, "%s: about to insert REGister: %s ... ", __FUNCTION__, reg->name);
 753 #endif
 754
 755         for(tmp = setFirstItem(*set); tmp; tmp = setNextItem(*set)) {
 756                 if(!strcmp(tmp->name, reg->name))break;
 757         }
 758
 759         if(!tmp) {
 760                 addSet(set, reg);
 761 #if DEBUG_CHECK
 762                 fprintf(stderr, "added\n");
 763 #endif
 764                 return 1;
 765         }
 766
 767 #if DEBUG_CHECK
 768         fprintf(stderr, "already added\n");
 769 #endif
 770   return 0;
 771 }
 772
 773 int checkAddSym(set **set, symbol *sym)
 774 {
 775   symbol *tmp;
 776
 777 #if DEBUG_CHECK
 778         fprintf(stderr, "%s: about to add SYMbol: %s ... ", __FUNCTION__, sym->name);
 779 #endif
 780
 781         for(tmp = setFirstItem( *set ); tmp; tmp = setNextItem(*set)) {
 782                 if(!strcmp(tmp->name, sym->name))break;
 783         }
 784
 785         if(!tmp) {
 786                 addSet(set, sym);
 787 #if DEBUG_CHECK
 788                 fprintf(stderr, "added\n");
 789 #endif
 790                 return 1;
 791         }
 792
 793 #if DEBUG_CHECK
 794         fprintf(stderr, "already added\n");
 795 #endif
 796
 797   return 0;
 798 }
 799
 800
 801 /*-----------------------------------------------------------------*
 802  * void pic16_groupRegistersInSection - add each register to its   *
 803  *      corresponding section                                      *
 804  *-----------------------------------------------------------------*/
 805 void pic16_groupRegistersInSection(set *regset)
 806 {
 807   regs *reg;
 808
 809         for(reg=setFirstItem(regset); reg; reg = setNextItem(regset)) {
 810
 811 //              fprintf(stderr, "%s:%d group registers in section, reg: %s\n", __FILE__, __LINE__, reg->name);
 812
 813                 if(reg->wasUsed
 814                         && !(reg->regop && SPEC_EXTR(OP_SYM_ETYPE(reg->regop)))) {
 815
 816                         /* avoid grouping registers that have an initial value,
 817                          * they will be added later in idataSymSet */
 818                         if(reg->regop && (OP_SYMBOL(reg->regop)->ival && !OP_SYMBOL(reg->regop)->level))
 819                                 continue;
 820
 821 #if 0
 822                         fprintf(stderr, "%s:%d register %s alias:%d fix:%d ival=%i level=%i\n",
 823                                 __FILE__, __LINE__, reg->name, reg->alias, reg->isFixed,
 824                                         (reg->regop?(OP_SYMBOL(reg->regop)->ival?1:0):-1),
 825                                         (reg->regop?(OP_SYMBOL(reg->regop)->level):-1) );
 826 #endif
 827
 828                         if(reg->alias == 0x80) {
 829                                 checkAddReg(&pic16_equ_data, reg);
 830                         } else
 831                         if(reg->isFixed) {
 832                                 checkAddReg(&pic16_fix_udata, reg);
 833                         } else
 834                         if(!reg->isFixed) {
 835                                 if(reg->pc_type == PO_GPR_TEMP)
 836                                         checkAddReg(&pic16_int_regs, reg);
 837                                 else
 838                                         checkAddReg(&pic16_rel_udata, reg);
 839                         }
 840                 }
 841         }
 842 }
 843
 844
 845
 846
 847
 848 /*-----------------------------------------------------------------*
 849  *  void pic16_assignConfigWordValue(int address, int value)
 850  *
 851  * All high performance RISC CPU PICs have seven config word starting
 852  * at address 0x300000.
 853  * This routine will assign a value to that address.
 854  *
 855  *-----------------------------------------------------------------*/
 856 void pic16_assignConfigWordValue(int address, int value)
 857 {
 858   int i;
 859
 860         for(i=0;i<pic16->cwInfo.confAddrEnd-pic16->cwInfo.confAddrStart+1;i++) {
 861                 if((address == pic16->cwInfo.confAddrStart+i)
 862                   && (pic16->cwInfo.crInfo[i].mask != -1)) {
 863 //                        fprintf(stderr, "setting location 0x%X to value 0x%x\n", /*address*/ pic16->cwInfo.confAddrStart+i, val
 864                         pic16->cwInfo.crInfo[i].value = value;
 865                         pic16->cwInfo.crInfo[i].emit = 1;
 866                         return;
 867                 }
 868         }
 869 }
 870