export CARAVEL_ROOT=/opt/caravel && make -f /opt/caravel/Makefile check-env
make[1]: Entering directory `/root/project'
make[1]: Nothing to be done for `check-env'.
make[1]: Leaving directory `/root/project'
export CARAVEL_ROOT=/opt/caravel && make -f /opt/caravel/Makefile uncompress
make[1]: Entering directory `/root/project'
mag/user_project_wrapper.mag.gz -> mag/user_project_wrapper.mag
mag/wb_interconnect.mag.gz -> mag/wb_interconnect.mag
mag/syntacore.mag.gz -> mag/syntacore.mag
mag/mbist.mag.gz -> mag/mbist.mag
mag/glbl_cfg.mag.gz -> mag/glbl_cfg.mag
mag/sdram.mag.gz -> mag/sdram.mag
mag/uart_i2cm_usb.mag.gz -> mag/uart_i2cm_usb.mag
mag/spi_master.mag.gz -> mag/spi_master.mag
mag/wb_host.mag.gz -> mag/wb_host.mag
spi/lvs/mbist.spice.gz -> spi/lvs/mbist.spice
spi/lvs/wb_host.spice.gz -> spi/lvs/wb_host.spice
spi/lvs/syntacore.spice.gz -> spi/lvs/syntacore.spice
spi/lvs/wb_interconnect.spice.gz -> spi/lvs/wb_interconnect.spice
spi/lvs/uart_i2cm_usb.spice.gz -> spi/lvs/uart_i2cm_usb.spice
spi/lvs/sdram.spice.gz -> spi/lvs/sdram.spice
spi/lvs/spi_master.spice.gz -> spi/lvs/spi_master.spice
spi/lvs/user_project_wrapper.spice.gz -> spi/lvs/user_project_wrapper.spice
spi/lvs/glbl_cfg.spice.gz -> spi/lvs/glbl_cfg.spice
lef/wb_interconnect.lef.gz -> lef/wb_interconnect.lef
lef/sdram.lef.gz -> lef/sdram.lef
lef/wb_host.lef.gz -> lef/wb_host.lef
lef/glbl_cfg.lef.gz -> lef/glbl_cfg.lef
lef/uart_i2cm_usb.lef.gz -> lef/uart_i2cm_usb.lef
lef/mbist.lef.gz -> lef/mbist.lef
lef/user_project_wrapper.lef.gz -> lef/user_project_wrapper.lef
lef/syntacore.lef.gz -> lef/syntacore.lef
lef/sky130_sram_2kbyte_1rw1r_32x512_8.lef.gz -> lef/sky130_sram_2kbyte_1rw1r_32x512_8.lef
lef/spi_master.lef.gz -> lef/spi_master.lef
gds/spi_master.gds.gz -> gds/spi_master.gds
gds/mbist.gds.gz -> gds/mbist.gds
gds/wb_interconnect.gds.gz -> gds/wb_interconnect.gds
gds/sdram.gds.gz -> gds/sdram.gds
gds/syntacore.gds.gz -> gds/syntacore.gds
gds/glbl_cfg.gds.gz -> gds/glbl_cfg.gds
gds/user_project_wrapper.gds.gz -> gds/user_project_wrapper.gds
gds/wb_host.gds.gz -> gds/wb_host.gds
gds/uart_i2cm_usb.gds.gz -> gds/uart_i2cm_usb.gds
gds/sky130_sram_2kbyte_1rw1r_32x512_8.gds.gz -> gds/sky130_sram_2kbyte_1rw1r_32x512_8.gds
maglef/user_project_wrapper.mag.gz -> maglef/user_project_wrapper.mag
maglef/wb_interconnect.mag.gz -> maglef/wb_interconnect.mag
maglef/syntacore.mag.gz -> maglef/syntacore.mag
maglef/mbist.mag.gz -> maglef/mbist.mag
maglef/glbl_cfg.mag.gz -> maglef/glbl_cfg.mag
maglef/sdram.mag.gz -> maglef/sdram.mag
maglef/uart_i2cm_usb.mag.gz -> maglef/uart_i2cm_usb.mag
maglef/spi_master.mag.gz -> maglef/spi_master.mag
maglef/wb_host.mag.gz -> maglef/wb_host.mag
def/syntacore.def.gz -> def/syntacore.def
def/uart_i2cm_usb.def.gz -> def/uart_i2cm_usb.def
def/spi_master.def.gz -> def/spi_master.def
def/wb_host.def.gz -> def/wb_host.def
def/wb_interconnect.def.gz -> def/wb_interconnect.def
def/mbist.def.gz -> def/mbist.def
def/user_project_wrapper.def.gz -> def/user_project_wrapper.def
def/sdram.def.gz -> def/sdram.def
def/glbl_cfg.def.gz -> def/glbl_cfg.def
spef/wb_interconnect.spef.gz -> spef/wb_interconnect.spef
spef/glbl_cfg.spef.gz -> spef/glbl_cfg.spef
spef/uart_i2c_usb_top.spef.gz -> spef/uart_i2c_usb_top.spef
spef/user_project_wrapper.spef.gz -> spef/user_project_wrapper.spef
spef/spim_top.spef.gz -> spef/spim_top.spef
spef/wb_host.spef.gz -> spef/wb_host.spef
spef/sdrc_top.spef.gz -> spef/sdrc_top.spef
spef/scr1_top_wb.spef.gz -> spef/scr1_top_wb.spef
spef/mbist_top.spef.gz -> spef/mbist_top.spef
All files are uncompressed!
make[1]: Leaving directory `/root/project'
export CARAVEL_ROOT=/opt/caravel && make -f /opt/caravel/Makefile uncompress-caravel
make[1]: Entering directory `/root/project'
cd /opt/caravel && \
make uncompress
make[2]: Entering directory `/opt/caravel'
All files are uncompressed!
make[2]: Leaving directory `/opt/caravel'
make[1]: Leaving directory `/root/project'
