Commit: 8918ad345ba53737ba90955a2cde90be0f42e6d5 - kmbasic2 (git)

BASIC compiler/interpreter for PIC32MX/MZ-80K

Commit MetaInfo

• Revisão: 8918ad345ba53737ba90955a2cde90be0f42e6d5 (tree)
• Hora: 2019-05-08 10:36:06
• Autor: Katsumi <kmorimatsu@sour...>
• Commiter: Katsumi

Mensagem de Log

Begin CLIB implementation.

Mudança Sumário

• add: mips/clib/clib.c
• add: mips/clib/clib.h
• add: mips/clib/clib.mcp
• add: mips/clib/clib_p32MX370F512H.ld
• add: mips/clib/example.c

Diff

--- /dev/null
+++ b/mips/clib/clib.c
@@ -0,0 +1,25 @@
+/***********************************
+ *                                 *
+ * Template of CLIB for MachiKania *
+ *                                 *
+ ***********************************/
+
+#include "./clib.h"
+
+// main() function is not used, but necessary for compiling
+void main(void){
+	while(1);
+}
+
+// Data list to provide addresses of constants[] and functions[]
+CLIBDATA unsigned int clibdata[]={
+	(unsigned int)&constants[0],
+	(unsigned int)&functions[0]
+};
+
+// Infinite loop at the beginning of program
+/*const __attribute__((address(0x9d007000))) unsigned int const _loop[]={
+	            // loop:
+	0x1000FFFF, // b loop
+	0x00000000  // nop
+};//*/

--- /dev/null
+++ b/mips/clib/clib.h
@@ -0,0 +1,16 @@
+/***********************************
+ *                                 *
+ * Template of CLIB for MachiKania *
+ *                                 *
+ ***********************************/
+
+// All CLIB functions must be written in .machikania_club section.
+#define CLIB __attribute__((section(".machikania_clib")))
+
+// CLIB data is placed at specific address
+#define CLIBDATA const __attribute__((address(0x9d01ff00)))
+
+// Global variables
+// These must be defined by user
+extern const void* const constants[];
+extern const void* const functions[];

--- /dev/null
+++ b/mips/clib/clib.mcp
@@ -0,0 +1,62 @@
+[HEADER]
+magic_cookie={66E99B07-E706-4689-9E80-9B2582898A13}
+file_version=1.0
+device=PIC32MX350F256H
+[PATH_INFO]
+BuildDirPolicy=BuildDirIsProjectDir
+dir_src=
+dir_bin=
+dir_tmp=
+dir_sin=
+dir_inc=
+dir_lib=C:\Program Files\Microchip\xc32\v1.42\pic32mx\lib
+dir_lkr=
+[CAT_FILTERS]
+filter_src=*.s;*.c
+filter_inc=*.h;*.inc
+filter_obj=*.o
+filter_lib=*.a
+filter_lkr=*.ld
+[CAT_SUBFOLDERS]
+subfolder_src=
+subfolder_inc=
+subfolder_obj=
+subfolder_lib=
+subfolder_lkr=
+[FILE_SUBFOLDERS]
+file_000=.
+file_001=.
+file_002=.
+file_003=.
+[GENERATED_FILES]
+file_000=no
+file_001=no
+file_002=no
+file_003=no
+[OTHER_FILES]
+file_000=no
+file_001=no
+file_002=no
+file_003=no
+[FILE_INFO]
+file_000=clib.c
+file_001=example.c
+file_002=clib.h
+file_003=clib_p32MX370F512H.ld
+[SUITE_INFO]
+suite_guid={62D235D8-2DB2-49CD-AF24-5489A6015337}
+suite_state=
+[TOOL_SETTINGS]
+TS{6F324298-6323-4781-8C43-43FA5E6F3646}=-gdwarf-2
+TS{1F324EFA-C0BA-4A8F-A85A-B21644939CAD}=-g -O1
+TS{29D3B6CC-DCAB-4659-8011-FFF75BB7F8D7}=-Map="$(BINDIR_)$(TARGETBASE).map" -o"$(BINDIR_)$(TARGETBASE).$(TARGETSUFFIX)" -O1 -nostdlib -mno-float
+TS{AD4C3FBD-B6BB-4F50-AB4E-35BF132D4D60}=
+[INSTRUMENTED_TRACE]
+enable=0
+transport=0
+format=0
+[CUSTOM_BUILD]
+Pre-Build=
+Pre-BuildEnabled=1
+Post-Build=
+Post-BuildEnabled=1

--- /dev/null
+++ b/mips/clib/clib_p32MX370F512H.ld
@@ -0,0 +1,804 @@
+/*--------------------------------------------------------------------------
+ * MPLAB XC Compiler -  PIC32MX370F512H linker script
+ * 
+ * This software is developed by Microchip Technology Inc. and its
+ * subsidiaries ("Microchip").
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * 1.      Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ * 2.      Redistributions in binary form must reproduce the above 
+ *         copyright notice, this list of conditions and the following 
+ *         disclaimer in the documentation and/or other materials provided 
+ *         with the distribution.
+ * 3.      Microchip's name may not be used to endorse or promote products
+ *         derived from this software without specific prior written 
+ *         permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR PURPOSE ARE DISCLAIMED. IN NO EVENT 
+ * SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ *-------------------------------------------------------------------------*/
+
+/* Default linker script, for normal executables */
+
+/*  IMPORTANT: PIC32MX MCUs use two files for the default linker script: 
+ *    1) pic32mx/lib/ldscripts/elf32pic32.x (main linker script)
+ *    2) pic32mx/lib/proc/32MX370F512H/procdefs.ld (variant-specific fragment)
+ *
+ *  This file is provided only as a convenience when adding a custom linker script
+ *  to your application.
+ */
+
+OUTPUT_FORMAT("elf32-tradlittlemips")
+OUTPUT_ARCH(pic32mx)
+ENTRY(_reset)
+/*
+ * Provide for a minimum stack and heap size
+ * - _min_stack_size - represents the minimum space that must be made
+ *                     available for the stack.  Can be overridden from
+ *                     the command line using the linker's --defsym option.
+ * - _min_heap_size  - represents the minimum space that must be made
+ *                     available for the heap.  Must be specified on
+ *                     the command line using the linker's --defsym option.
+ */
+EXTERN (_min_stack_size _min_heap_size)
+PROVIDE(_min_stack_size = 0x800) ;
+
+/*************************************************************************
+ * Processor-specific object file.  Contains SFR definitions.
+ *************************************************************************/
+INPUT("processor.o")
+
+/*************************************************************************
+ * Processor-specific peripheral libraries are optional
+ *************************************************************************/
+OPTIONAL("libmchp_peripheral.a")
+OPTIONAL("libmchp_peripheral_32MX370F512H.a")
+
+/*************************************************************************
+ * For interrupt vector handling
+ *************************************************************************/
+PROVIDE(_vector_spacing = 0x00000001);
+_ebase_address = 0x9D006000;
+
+/*************************************************************************
+ * Memory Address Equates
+ * _RESET_ADDR                    -- Reset Vector
+ * _BEV_EXCPT_ADDR                -- Boot exception Vector
+ * _DBG_EXCPT_ADDR                -- In-circuit Debugging Exception Vector
+ * _DBG_CODE_ADDR                 -- In-circuit Debug Executive address
+ * _DBG_CODE_SIZE                 -- In-circuit Debug Executive size
+ * _GEN_EXCPT_ADDR                -- General Exception Vector
+ *************************************************************************/
+_RESET_ADDR                    = (0x9D006000 + 0x1000);
+_BEV_EXCPT_ADDR                = (0x9D006000 + 0x1000 + 0x380);
+_DBG_EXCPT_ADDR                = (0x9D006000 + 0x1000 + 0x480);
+_DBG_CODE_ADDR                 = 0xBFC02000;
+_DBG_CODE_SIZE                 = 0xFF0;
+_GEN_EXCPT_ADDR                = _ebase_address + 0x180;
+
+/*************************************************************************
+ * Memory Regions
+ *
+ * Memory regions without attributes cannot be used for orphaned sections.
+ * Only sections specifically assigned to these regions can be allocated
+ * into these regions.
+ *
+ * The Debug exception vector is located at 0x9FC00480.
+ * The config_<address> sections are used to locate the config words at
+ * their absolute addresses.
+ *************************************************************************/
+MEMORY
+{
+  kseg0_program_mem     (rx)  : ORIGIN = (0x9D006000+0x1000+0x490), LENGTH = (0x20000-0x6000-0x1000-0x490)
+  kseg2_program_mem     (rx)  : ORIGIN = (0x9D020000), LENGTH = (0x80000-0x20000-0x1000)
+  kseg0_boot_mem              : ORIGIN = (0x9D006000+0x1000+0x490), LENGTH = 0 /* dummy */
+  exception_mem               : ORIGIN = 0x9D006000, LENGTH = 0x1000
+  kseg1_boot_mem              : ORIGIN = (0x9D006000+0x1000), LENGTH = 0x490
+  debug_exec_mem              : ORIGIN = 0xBFC02000, LENGTH = 0xFF0
+  config3                     : ORIGIN = 0xBFC02FF0, LENGTH = 0x4
+  config2                     : ORIGIN = 0xBFC02FF4, LENGTH = 0x4
+  config1                     : ORIGIN = 0xBFC02FF8, LENGTH = 0x4
+  config0                     : ORIGIN = 0xBFC02FFC, LENGTH = 0x4
+  kseg1_data_mem       (w!x)  : ORIGIN = 0xA0000000, LENGTH = 0x20000
+  sfrs                        : ORIGIN = 0xBF800000, LENGTH = 0x100000
+  configsfrs                  : ORIGIN = 0xBFC02FF0, LENGTH = 0x10
+}
+
+/*
+  MachiKania C library specific section follows
+*/
+
+SECTIONS
+{
+  .machikania_object : {
+    KEEP(*(.machikania_clib))
+  } > kseg2_program_mem
+}
+
+/*************************************************************************
+ * Configuration-word sections. Map the config-pragma input sections to
+ * absolute-address output sections.
+ *************************************************************************/
+SECTIONS
+{
+  .config_BFC02FF0 : {
+    KEEP(*(.config_BFC02FF0))
+  } > config3
+  .config_BFC02FF4 : {
+    KEEP(*(.config_BFC02FF4))
+  } > config2
+  .config_BFC02FF8 : {
+    KEEP(*(.config_BFC02FF8))
+  } > config1
+  .config_BFC02FFC : {
+    KEEP(*(.config_BFC02FFC))
+  } > config0
+}
+SECTIONS
+{
+  /* Boot Sections */
+  .reset _RESET_ADDR :
+  {
+    KEEP(*(.reset))
+    KEEP(*(.reset.startup))
+  } > kseg1_boot_mem
+  .bev_excpt _BEV_EXCPT_ADDR :
+  {
+    KEEP(*(.bev_handler))
+  } > kseg1_boot_mem
+  /* Debug exception vector */
+  .dbg_excpt _DBG_EXCPT_ADDR (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? 0x8 : 0x0);
+  } > kseg1_boot_mem
+  /* Space reserved for the debug executive */
+  .dbg_code _DBG_CODE_ADDR (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? _DBG_CODE_SIZE : 0x0);
+  } > debug_exec_mem
+
+  .app_excpt _GEN_EXCPT_ADDR :
+  {
+    KEEP(*(.gen_handler))
+  } > exception_mem
+
+  .vector_0 _ebase_address + 0x200 + ((_vector_spacing << 5) * 0) :
+  {
+     KEEP(*(.vector_0))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_0) <= (_vector_spacing << 5), "function at exception vector 0 too large")
+  .vector_1 _ebase_address + 0x200 + ((_vector_spacing << 5) * 1) :
+  {
+     KEEP(*(.vector_1))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_1) <= (_vector_spacing << 5), "function at exception vector 1 too large")
+  .vector_2 _ebase_address + 0x200 + ((_vector_spacing << 5) * 2) :
+  {
+     KEEP(*(.vector_2))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_2) <= (_vector_spacing << 5), "function at exception vector 2 too large")
+  .vector_3 _ebase_address + 0x200 + ((_vector_spacing << 5) * 3) :
+  {
+     KEEP(*(.vector_3))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_3) <= (_vector_spacing << 5), "function at exception vector 3 too large")
+  .vector_4 _ebase_address + 0x200 + ((_vector_spacing << 5) * 4) :
+  {
+     KEEP(*(.vector_4))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_4) <= (_vector_spacing << 5), "function at exception vector 4 too large")
+  .vector_5 _ebase_address + 0x200 + ((_vector_spacing << 5) * 5) :
+  {
+     KEEP(*(.vector_5))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_5) <= (_vector_spacing << 5), "function at exception vector 5 too large")
+  .vector_6 _ebase_address + 0x200 + ((_vector_spacing << 5) * 6) :
+  {
+     KEEP(*(.vector_6))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_6) <= (_vector_spacing << 5), "function at exception vector 6 too large")
+  .vector_7 _ebase_address + 0x200 + ((_vector_spacing << 5) * 7) :
+  {
+     KEEP(*(.vector_7))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_7) <= (_vector_spacing << 5), "function at exception vector 7 too large")
+  .vector_8 _ebase_address + 0x200 + ((_vector_spacing << 5) * 8) :
+  {
+     KEEP(*(.vector_8))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_8) <= (_vector_spacing << 5), "function at exception vector 8 too large")
+  .vector_9 _ebase_address + 0x200 + ((_vector_spacing << 5) * 9) :
+  {
+     KEEP(*(.vector_9))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_9) <= (_vector_spacing << 5), "function at exception vector 9 too large")
+  .vector_10 _ebase_address + 0x200 + ((_vector_spacing << 5) * 10) :
+  {
+     KEEP(*(.vector_10))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_10) <= (_vector_spacing << 5), "function at exception vector 10 too large")
+  .vector_11 _ebase_address + 0x200 + ((_vector_spacing << 5) * 11) :
+  {
+     KEEP(*(.vector_11))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_11) <= (_vector_spacing << 5), "function at exception vector 11 too large")
+  .vector_12 _ebase_address + 0x200 + ((_vector_spacing << 5) * 12) :
+  {
+     KEEP(*(.vector_12))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_12) <= (_vector_spacing << 5), "function at exception vector 12 too large")
+  .vector_13 _ebase_address + 0x200 + ((_vector_spacing << 5) * 13) :
+  {
+     KEEP(*(.vector_13))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_13) <= (_vector_spacing << 5), "function at exception vector 13 too large")
+  .vector_14 _ebase_address + 0x200 + ((_vector_spacing << 5) * 14) :
+  {
+     KEEP(*(.vector_14))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_14) <= (_vector_spacing << 5), "function at exception vector 14 too large")
+  .vector_15 _ebase_address + 0x200 + ((_vector_spacing << 5) * 15) :
+  {
+     KEEP(*(.vector_15))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_15) <= (_vector_spacing << 5), "function at exception vector 15 too large")
+  .vector_16 _ebase_address + 0x200 + ((_vector_spacing << 5) * 16) :
+  {
+     KEEP(*(.vector_16))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_16) <= (_vector_spacing << 5), "function at exception vector 16 too large")
+  .vector_17 _ebase_address + 0x200 + ((_vector_spacing << 5) * 17) :
+  {
+     KEEP(*(.vector_17))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_17) <= (_vector_spacing << 5), "function at exception vector 17 too large")
+  .vector_18 _ebase_address + 0x200 + ((_vector_spacing << 5) * 18) :
+  {
+     KEEP(*(.vector_18))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_18) <= (_vector_spacing << 5), "function at exception vector 18 too large")
+  .vector_19 _ebase_address + 0x200 + ((_vector_spacing << 5) * 19) :
+  {
+     KEEP(*(.vector_19))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_19) <= (_vector_spacing << 5), "function at exception vector 19 too large")
+  .vector_20 _ebase_address + 0x200 + ((_vector_spacing << 5) * 20) :
+  {
+     KEEP(*(.vector_20))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_20) <= (_vector_spacing << 5), "function at exception vector 20 too large")
+  .vector_21 _ebase_address + 0x200 + ((_vector_spacing << 5) * 21) :
+  {
+     KEEP(*(.vector_21))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_21) <= (_vector_spacing << 5), "function at exception vector 21 too large")
+  .vector_22 _ebase_address + 0x200 + ((_vector_spacing << 5) * 22) :
+  {
+     KEEP(*(.vector_22))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_22) <= (_vector_spacing << 5), "function at exception vector 22 too large")
+  .vector_23 _ebase_address + 0x200 + ((_vector_spacing << 5) * 23) :
+  {
+     KEEP(*(.vector_23))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_23) <= (_vector_spacing << 5), "function at exception vector 23 too large")
+  .vector_24 _ebase_address + 0x200 + ((_vector_spacing << 5) * 24) :
+  {
+     KEEP(*(.vector_24))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_24) <= (_vector_spacing << 5), "function at exception vector 24 too large")
+  .vector_25 _ebase_address + 0x200 + ((_vector_spacing << 5) * 25) :
+  {
+     KEEP(*(.vector_25))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_25) <= (_vector_spacing << 5), "function at exception vector 25 too large")
+  .vector_26 _ebase_address + 0x200 + ((_vector_spacing << 5) * 26) :
+  {
+     KEEP(*(.vector_26))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_26) <= (_vector_spacing << 5), "function at exception vector 26 too large")
+  .vector_27 _ebase_address + 0x200 + ((_vector_spacing << 5) * 27) :
+  {
+     KEEP(*(.vector_27))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_27) <= (_vector_spacing << 5), "function at exception vector 27 too large")
+  .vector_28 _ebase_address + 0x200 + ((_vector_spacing << 5) * 28) :
+  {
+     KEEP(*(.vector_28))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_28) <= (_vector_spacing << 5), "function at exception vector 28 too large")
+  .vector_29 _ebase_address + 0x200 + ((_vector_spacing << 5) * 29) :
+  {
+     KEEP(*(.vector_29))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_29) <= (_vector_spacing << 5), "function at exception vector 29 too large")
+  .vector_30 _ebase_address + 0x200 + ((_vector_spacing << 5) * 30) :
+  {
+     KEEP(*(.vector_30))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_30) <= (_vector_spacing << 5), "function at exception vector 30 too large")
+  .vector_31 _ebase_address + 0x200 + ((_vector_spacing << 5) * 31) :
+  {
+     KEEP(*(.vector_31))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_31) <= (_vector_spacing << 5), "function at exception vector 31 too large")
+  .vector_32 _ebase_address + 0x200 + ((_vector_spacing << 5) * 32) :
+  {
+     KEEP(*(.vector_32))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_32) <= (_vector_spacing << 5), "function at exception vector 32 too large")
+  .vector_33 _ebase_address + 0x200 + ((_vector_spacing << 5) * 33) :
+  {
+     KEEP(*(.vector_33))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_33) <= (_vector_spacing << 5), "function at exception vector 33 too large")
+  .vector_34 _ebase_address + 0x200 + ((_vector_spacing << 5) * 34) :
+  {
+     KEEP(*(.vector_34))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_34) <= (_vector_spacing << 5), "function at exception vector 34 too large")
+  .vector_35 _ebase_address + 0x200 + ((_vector_spacing << 5) * 35) :
+  {
+     KEEP(*(.vector_35))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_35) <= (_vector_spacing << 5), "function at exception vector 35 too large")
+  .vector_36 _ebase_address + 0x200 + ((_vector_spacing << 5) * 36) :
+  {
+     KEEP(*(.vector_36))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_36) <= (_vector_spacing << 5), "function at exception vector 36 too large")
+  .vector_37 _ebase_address + 0x200 + ((_vector_spacing << 5) * 37) :
+  {
+     KEEP(*(.vector_37))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_37) <= (_vector_spacing << 5), "function at exception vector 37 too large")
+  .vector_38 _ebase_address + 0x200 + ((_vector_spacing << 5) * 38) :
+  {
+     KEEP(*(.vector_38))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_38) <= (_vector_spacing << 5), "function at exception vector 38 too large")
+  .vector_39 _ebase_address + 0x200 + ((_vector_spacing << 5) * 39) :
+  {
+     KEEP(*(.vector_39))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_39) <= (_vector_spacing << 5), "function at exception vector 39 too large")
+  .vector_40 _ebase_address + 0x200 + ((_vector_spacing << 5) * 40) :
+  {
+     KEEP(*(.vector_40))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_40) <= (_vector_spacing << 5), "function at exception vector 40 too large")
+  .vector_41 _ebase_address + 0x200 + ((_vector_spacing << 5) * 41) :
+  {
+     KEEP(*(.vector_41))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_41) <= (_vector_spacing << 5), "function at exception vector 41 too large")
+  .vector_42 _ebase_address + 0x200 + ((_vector_spacing << 5) * 42) :
+  {
+     KEEP(*(.vector_42))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_42) <= (_vector_spacing << 5), "function at exception vector 42 too large")
+  .vector_43 _ebase_address + 0x200 + ((_vector_spacing << 5) * 43) :
+  {
+     KEEP(*(.vector_43))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_43) <= (_vector_spacing << 5), "function at exception vector 43 too large")
+  .vector_44 _ebase_address + 0x200 + ((_vector_spacing << 5) * 44) :
+  {
+     KEEP(*(.vector_44))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_44) <= (_vector_spacing << 5), "function at exception vector 44 too large")
+  .vector_45 _ebase_address + 0x200 + ((_vector_spacing << 5) * 45) :
+  {
+     KEEP(*(.vector_45))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_45) <= (_vector_spacing << 5), "function at exception vector 45 too large")
+  .vector_46 _ebase_address + 0x200 + ((_vector_spacing << 5) * 46) :
+  {
+     KEEP(*(.vector_46))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_46) <= (_vector_spacing << 5), "function at exception vector 46 too large")
+  .vector_47 _ebase_address + 0x200 + ((_vector_spacing << 5) * 47) :
+  {
+     KEEP(*(.vector_47))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_47) <= (_vector_spacing << 5), "function at exception vector 47 too large")
+  .vector_48 _ebase_address + 0x200 + ((_vector_spacing << 5) * 48) :
+  {
+     KEEP(*(.vector_48))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_48) <= (_vector_spacing << 5), "function at exception vector 48 too large")
+  .vector_49 _ebase_address + 0x200 + ((_vector_spacing << 5) * 49) :
+  {
+     KEEP(*(.vector_49))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_49) <= (_vector_spacing << 5), "function at exception vector 49 too large")
+  .vector_50 _ebase_address + 0x200 + ((_vector_spacing << 5) * 50) :
+  {
+     KEEP(*(.vector_50))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_50) <= (_vector_spacing << 5), "function at exception vector 50 too large")
+  .vector_51 _ebase_address + 0x200 + ((_vector_spacing << 5) * 51) :
+  {
+     KEEP(*(.vector_51))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_51) <= (_vector_spacing << 5), "function at exception vector 51 too large")
+  .vector_52 _ebase_address + 0x200 + ((_vector_spacing << 5) * 52) :
+  {
+     KEEP(*(.vector_52))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_52) <= (_vector_spacing << 5), "function at exception vector 52 too large")
+  .vector_53 _ebase_address + 0x200 + ((_vector_spacing << 5) * 53) :
+  {
+     KEEP(*(.vector_53))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_53) <= (_vector_spacing << 5), "function at exception vector 53 too large")
+  .vector_54 _ebase_address + 0x200 + ((_vector_spacing << 5) * 54) :
+  {
+     KEEP(*(.vector_54))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_54) <= (_vector_spacing << 5), "function at exception vector 54 too large")
+  .vector_55 _ebase_address + 0x200 + ((_vector_spacing << 5) * 55) :
+  {
+     KEEP(*(.vector_55))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_55) <= (_vector_spacing << 5), "function at exception vector 55 too large")
+  .vector_56 _ebase_address + 0x200 + ((_vector_spacing << 5) * 56) :
+  {
+     KEEP(*(.vector_56))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_56) <= (_vector_spacing << 5), "function at exception vector 56 too large")
+  .vector_57 _ebase_address + 0x200 + ((_vector_spacing << 5) * 57) :
+  {
+     KEEP(*(.vector_57))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_57) <= (_vector_spacing << 5), "function at exception vector 57 too large")
+  .vector_58 _ebase_address + 0x200 + ((_vector_spacing << 5) * 58) :
+  {
+     KEEP(*(.vector_58))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_58) <= (_vector_spacing << 5), "function at exception vector 58 too large")
+  .vector_59 _ebase_address + 0x200 + ((_vector_spacing << 5) * 59) :
+  {
+     KEEP(*(.vector_59))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_59) <= (_vector_spacing << 5), "function at exception vector 59 too large")
+  .vector_60 _ebase_address + 0x200 + ((_vector_spacing << 5) * 60) :
+  {
+     KEEP(*(.vector_60))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_60) <= (_vector_spacing << 5), "function at exception vector 60 too large")
+  .vector_61 _ebase_address + 0x200 + ((_vector_spacing << 5) * 61) :
+  {
+     KEEP(*(.vector_61))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_61) <= (_vector_spacing << 5), "function at exception vector 61 too large")
+  .vector_62 _ebase_address + 0x200 + ((_vector_spacing << 5) * 62) :
+  {
+     KEEP(*(.vector_62))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_62) <= (_vector_spacing << 5), "function at exception vector 62 too large")
+  .vector_63 _ebase_address + 0x200 + ((_vector_spacing << 5) * 63) :
+  {
+     KEEP(*(.vector_63))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_63) <= (_vector_spacing << 5), "function at exception vector 63 too large")
+
+  /*  The startup code is in the .reset.startup section.
+   *  Keep this here for backwards compatibility with older
+   *  C32 v1.xx releases.
+   */
+  .startup ORIGIN(kseg0_boot_mem) :
+  {
+    KEEP(*(.startup))
+  } > kseg0_boot_mem
+  /* Code Sections - Note that input sections *(.text) and *(.text.*)
+  ** are not mapped here. The best-fit allocator locates them,
+  ** so that .text may flow around absolute sections as needed.
+  */
+  .text :
+  {
+    *(.stub .gnu.linkonce.t.*)
+    KEEP (*(.text.*personality*))
+    *(.mips16.fn.*)
+    *(.mips16.call.*)
+    *(.gnu.warning)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /* Global-namespace object initialization */
+  .init   :
+  {
+    KEEP (*crti.o(.init))
+    KEEP (*crtbegin.o(.init))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o *crtn.o ).init))
+    KEEP (*crtend.o(.init))
+    KEEP (*crtn.o(.init))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .fini   :
+  {
+    KEEP (*(.fini))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .preinit_array   :
+  {
+    PROVIDE_HIDDEN (__preinit_array_start = .);
+    KEEP (*(.preinit_array))
+    PROVIDE_HIDDEN (__preinit_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .init_array   :
+  {
+    PROVIDE_HIDDEN (__init_array_start = .);
+    KEEP (*(SORT(.init_array.*)))
+    KEEP (*(.init_array))
+    PROVIDE_HIDDEN (__init_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .fini_array   :
+  {
+    PROVIDE_HIDDEN (__fini_array_start = .);
+    KEEP (*(SORT(.fini_array.*)))
+    KEEP (*(.fini_array))
+    PROVIDE_HIDDEN (__fini_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .ctors   :
+  {
+    /* XC32 uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    /* We don't want to include the .ctor section from
+       the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .dtors   :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /* Read-only sections */
+  .rodata   :
+  {
+    *( .gnu.linkonce.r.*)
+    *(.rodata1)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /*
+   * Small initialized constant global and static data can be placed in the
+   * .sdata2 section.  This is different from .sdata, which contains small
+   * initialized non-constant global and static data.
+   */
+  .sdata2 ALIGN(4) :
+  {
+    *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /*
+   * Uninitialized constant global and static data (i.e., variables which will
+   * always be zero).  Again, this is different from .sbss, which contains
+   * small non-initialized, non-constant global and static data.
+   */
+  .sbss2 ALIGN(4) :
+  {
+    *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .eh_frame_hdr   :
+  {
+    *(.eh_frame_hdr)
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .eh_frame   : ONLY_IF_RO
+  {
+    KEEP (*(.eh_frame))
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .gcc_except_table   : ONLY_IF_RO
+  {
+    *(.gcc_except_table .gcc_except_table.*)
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .dbg_data (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? 0x200 : 0x0);
+  } >kseg1_data_mem
+  .jcr   :
+  {
+    KEEP (*(.jcr))
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  .eh_frame    : ONLY_IF_RW
+  {
+    KEEP (*(.eh_frame))
+  } >kseg1_data_mem
+    . = ALIGN(4) ;
+  .gcc_except_table    : ONLY_IF_RW
+  {
+    *(.gcc_except_table .gcc_except_table.*)
+  } >kseg1_data_mem
+    . = ALIGN(4) ;
+  /* Persistent data - Use the new C 'persistent' attribute instead. */
+  .persist   :
+  {
+    _persist_begin = .;
+    *(.persist .persist.*)
+    *(.pbss .pbss.*)
+    . = ALIGN(4) ;
+    _persist_end = .;
+  } >kseg1_data_mem
+  /*
+   *  Note that input sections named .data* are not mapped here.
+   *  The best-fit allocator locates them, so that they may flow
+   *  around absolute sections as needed.
+   */
+  .data   :
+  {
+    *( .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+    *(.data1)
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  . = .;
+  _gp = ALIGN(16) + 0x7ff0;
+  .got ALIGN(4) :
+  {
+    *(.got.plt) *(.got)
+    . = ALIGN(4) ;
+  } >kseg1_data_mem /* AT>kseg0_program_mem */
+  /*
+   * Note that 'small' data sections are still mapped in the linker
+   * script. This ensures that they are grouped together for
+   * gp-relative addressing. Absolute sections are allocated after
+   * the 'small' data sections so small data cannot flow around them.
+   */
+  /*
+   * We want the small data sections together, so single-instruction offsets
+   * can access them all, and initialized data all before uninitialized, so
+   * we can shorten the on-disk segment size.
+   */
+  .sdata ALIGN(4) :
+  {
+    _sdata_begin = . ;
+    *(.sdata .sdata.* .gnu.linkonce.s.*)
+    . = ALIGN(4) ;
+    _sdata_end = . ;
+  } >kseg1_data_mem
+  .lit8           :
+  {
+    *(.lit8)
+  } >kseg1_data_mem
+  .lit4           :
+  {
+    *(.lit4)
+  } >kseg1_data_mem
+  . = ALIGN (4) ;
+  _data_end = . ;
+  _bss_begin = . ;
+  .sbss ALIGN(4) :
+  {
+    _sbss_begin = . ;
+    *(.dynsbss)
+    *(.sbss .sbss.* .gnu.linkonce.sb.*)
+    *(.scommon)
+    _sbss_end = . ;
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  /*
+   *  Align here to ensure that the .bss section occupies space up to
+   *  _end.  Align after .bss to ensure correct alignment even if the
+   *  .bss section disappears because there are no input sections.
+   *
+   *  Note that input sections named .bss* are no longer mapped here.
+   *  The best-fit allocator locates them, so that they may flow
+   *  around absolute sections as needed.
+   *
+   */
+  .bss     :
+  {
+    *(.dynbss)
+    *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections. */
+   . = ALIGN(. != 0 ? 4 : 1);
+  } >kseg1_data_mem
+  . = ALIGN(4) ;
+  _end = . ;
+  _bss_end = . ;
+  /*
+   *  The heap and stack are best-fit allocated by the linker after other
+   *  data and bss sections have been allocated.
+   */
+  /*
+   * RAM functions go at the end of our stack and heap allocation.
+   * Alignment of 2K required by the boundary register (BMXDKPBA).
+   *
+   * RAM functions are now allocated by the linker. The linker generates
+   * _ramfunc_begin and _bmxdkpba_address symbols depending on the
+   * location of RAM functions.
+   */
+  _bmxdudba_address = LENGTH(kseg1_data_mem) ;
+  _bmxdupba_address = LENGTH(kseg1_data_mem) ;
+    /* The .pdr section belongs in the absolute section */
+    /DISCARD/ : { *(.pdr) }
+  .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }
+  .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }
+  .mdebug.abi32 : { KEEP(*(.mdebug.abi32)) }
+  .mdebug.abiN32 : { KEEP(*(.mdebug.abiN32)) }
+  .mdebug.abi64 : { KEEP(*(.mdebug.abi64)) }
+  .mdebug.abiO64 : { KEEP(*(.mdebug.abiO64)) }
+  .mdebug.eabi32 : { KEEP(*(.mdebug.eabi32)) }
+  .mdebug.eabi64 : { KEEP(*(.mdebug.eabi64)) }
+  .gcc_compiled_long32 : { KEEP(*(.gcc_compiled_long32)) }
+  .gcc_compiled_long64 : { KEEP(*(.gcc_compiled_long64)) }
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections used by MPLAB X for source-level debugging. 
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  /DISCARD/ : { *(.rel.dyn) }
+  .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
+  /DISCARD/ : { *(.note.GNU-stack) }
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) *(.discard) }
+}
+

--- /dev/null
+++ b/mips/clib/example.c
@@ -0,0 +1,51 @@
+/***********************************
+ *                                 *
+ * Template of CLIB for MachiKania *
+ *                                 *
+ ***********************************/
+#include <xc.h>
+#include "./clib.h"
+
+char** g_pconst;
+
+// The init() for initiation is required if string constant(s) will be used.
+// First parameter is the pointer to string constan(s) array
+// The initializations of global variables must be done here.
+// 文字列定数を使いたい時は、初期化関数init()は必須。
+// 第一引数は、文字列定数リストへのポインター。
+// グローバル変数の初期化は、この関数内で行なう必要あり。
+CLIB void init(char** pconstants){
+	g_pconst=pconstants;
+}
+
+// Example of a function.
+// The definition must start from "CLIB"
+// Maximum number of parameter(s) is 4.
+// 関数の実装例。
+// 関数定義は、「CLIB」で始める事。
+// 引数は、最大４つまで。
+CLIB char* test(int param1){
+	return g_pconst[0];
+}
+// The list of string constant(s)
+// This array must end with 0.
+// 文字列定数のリスト。
+// この配列の最終要素は、0 とすること。
+const void* const constants[]={
+	"STRCONSTANT1",
+	"STRCONSTANT2",
+	"STRCONSTANT3",
+	0
+};
+
+// The list of public function(s)
+// This defines the function name(s) and function address(s)
+// This array must end with 0.
+// パブリック関数のリスト。
+// 関数名と、関数のアドレスを指定する。
+// この配列の最終要素は、0 とすること。
+const void* const functions[]={
+	"INIT",init,
+	"TEST",test,
+	0
+};