Citra-emu/hwtests
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #42 from Subv/latest_ctrulib

Browse Source 
Updated the toolchain and fixed the build with the latest ctrulib.
This commit is contained in:
Sebastian Valle 2017-01-05 12:07:35 -05:00 committed by GitHub
commit e2e1b74c28
8 changed files with 87 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
Makefile
View File

@ -17,6 +17,7 @@ include $(DEVKITARM)/3ds_rules
# INCLUDES is a list of directories containing header files # INCLUDES is a list of directories containing header files
# #
# NO_SMDH: if set to anything, no SMDH file is generated. # NO_SMDH: if set to anything, no SMDH file is generated.
# ROMFS is the directory which contains the RomFS, relative to the Makefile (Optional)
# APP_TITLE is the name of the app stored in the SMDH file (Optional) # APP_TITLE is the name of the app stored in the SMDH file (Optional)
# APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional) # APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional)
# APP_AUTHOR is the author of the app stored in the SMDH file (Optional) # APP_AUTHOR is the author of the app stored in the SMDH file (Optional)
@ -31,14 +32,15 @@ BUILD := build
SOURCES := source source/common source/tests source/tests/fs source/tests/cpu source/tests/kernel source/tests/gpu SOURCES := source source/common source/tests source/tests/fs source/tests/cpu source/tests/kernel source/tests/gpu
DATA := data DATA := data
INCLUDES := source INCLUDES := source
#ROMFS := romfs
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# options for code generation # options for code generation
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
CFLAGS := -g -Wall -O2 -mword-relocations \ CFLAGS := -g -Wall -O2 -mword-relocations \
-fomit-frame-pointer -ffast-math \ -fomit-frame-pointer -ffunction-sections \
$(ARCH) $(ARCH)
CFLAGS += $(INCLUDE) -DARM11 -D_3DS CFLAGS += $(INCLUDE) -DARM11 -D_3DS
@ -75,6 +77,8 @@ export DEPSDIR := $(CURDIR)/$(BUILD)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c))) CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp))) CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s))) SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PICAFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica)))
SHLISTFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*))) BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
@ -92,6 +96,7 @@ endif
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \ export OFILES := $(addsuffix .o,$(BINFILES)) \
$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o) $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \ export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
@ -117,6 +122,10 @@ ifeq ($(strip $(NO_SMDH)),)
export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh
endif endif
ifneq ($(ROMFS),)
export _3DSXFLAGS += --romfs=$(CURDIR)/$(ROMFS)
endif
.PHONY: $(BUILD) clean all .PHONY: $(BUILD) clean all
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
@ -156,20 +165,32 @@ $(OUTPUT).elf : $(OFILES)
@echo $(notdir $<) @echo $(notdir $<)
@$(bin2o) @$(bin2o)
# WARNING: This is not the right way to do this! TODO: Do it right!
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
%.vsh.o : %.vsh # rules for assembling GPU shaders
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
define shader-as
$(eval CURBIN := $(patsubst %.shbin.o,%.shbin,$(notdir $@)))
picasso -o $(CURBIN) $1
bin2s $(CURBIN) | $(AS) -o $@
echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(CURBIN) | tr . _)`.h
echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h
echo "extern const u32" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(CURBIN) | tr . _)`.h
endef
%.shbin.o : %.v.pica %.g.pica
@echo $(notdir $^)
@$(call shader-as,$^)
%.shbin.o : %.v.pica
@echo $(notdir $<) @echo $(notdir $<)
@python $(AEMSTRO)/aemstro_as.py $< ../$(notdir $<).shbin @$(call shader-as,$<)
@bin2s ../$(notdir $<).shbin | $(PREFIX)as -o $@
@echo "extern const u8" `(echo $(notdir $<).shbin | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(notdir $<).shbin | tr . _)`.h %.shbin.o : %.shlist
@echo "extern const u8" `(echo $(notdir $<).shbin | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(notdir $<).shbin | tr . _)`.h @echo $(notdir $<)
@echo "extern const u32" `(echo $(notdir $<).shbin | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(notdir $<).shbin | tr . _)`.h @$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)/$(file)))
@rm ../$(notdir $<).shbin
-include $(DEPENDS) -include $(DEPENDS)
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
endif endif
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------

2
source/main.cpp
View File

@ -45,7 +45,7 @@ int main(int argc, char** argv)
Print("Press A to continue...\n"); Print("Press A to continue...\n");
} }
gspWaitForEvent(GSPEVENT_VBlank0, false); gspWaitForVBlank();
} }
consoleClear(); consoleClear();

4
source/tests/cpu/integer.cpp
View File

@ -55,9 +55,9 @@ static bool Sub() {
unsigned int output; unsigned int output;
// Generic subtraction. // Generic subtraction.
asm volatile ("LDR r0, =489\n" asm volatile ("MOV r0, #488\n"
"SUB %[out], r0, #69" : [out] "=r"(output)); "SUB %[out], r0, #69" : [out] "=r"(output));
if (output != 420) if (output != 419)
return false; return false;
// Subtract overflow (0 - 1). // Subtract overflow (0 - 1).

84
source/tests/fs/fs_sdmc.cpp
View File

@ -9,84 +9,84 @@
namespace FS { namespace FS {
namespace SDMC { namespace SDMC {
static bool TestFileCreateDelete(FS_archive sdmcArchive) static bool TestFileCreateDelete(FS_Archive sdmcArchive)
{ {
Handle fileHandle, fileHandle2; Handle fileHandle, fileHandle2;
const static FS_path filePath = FS_makePath(PATH_CHAR, "/test_file_create_delete.txt"); const static FS_Path filePath = fsMakePath(PATH_ASCII, "/test_file_create_delete.txt");
const static FS_path filePath2 = FS_makePath(PATH_CHAR, "/test_file_create_2.txt"); const static FS_Path filePath2 = fsMakePath(PATH_ASCII, "/test_file_create_2.txt");
// Create file with OpenFile (not interested in opening the handle) // Create file with OpenFile (not interested in opening the handle)
SoftAssert(FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE | FS_OPEN_WRITE, 0) == 0); SoftAssert(FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE | FS_OPEN_WRITE, 0) == 0);
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
// Make sure the new file exists // Make sure the new file exists
SoftAssert(FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) == 0); SoftAssert(FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) == 0);
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
SoftAssert(FSUSER_DeleteFile(NULL, sdmcArchive, filePath) == 0); SoftAssert(FSUSER_DeleteFile(sdmcArchive, filePath) == 0);
// Should fail to make sure the file no longer exists // Should fail to make sure the file no longer exists
SoftAssert(FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) != 0); SoftAssert(FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) != 0);
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
// Create file with CreateFile // Create file with CreateFile
SoftAssert(FSUSER_CreateFile(NULL, sdmcArchive, filePath2, 0) == 0); SoftAssert(FSUSER_CreateFile(sdmcArchive, filePath2, 0, 0) == 0);
SCOPE_EXIT({ SCOPE_EXIT({
FSFILE_Close(fileHandle2); FSFILE_Close(fileHandle2);
FSUSER_DeleteFile(NULL, sdmcArchive, filePath2); FSUSER_DeleteFile(sdmcArchive, filePath2);
}); });
// Make sure the new file exists // Make sure the new file exists
SoftAssert(FSUSER_OpenFile(NULL, &fileHandle2, sdmcArchive, filePath2, FS_OPEN_READ, 0) == 0); SoftAssert(FSUSER_OpenFile(&fileHandle2, sdmcArchive, filePath2, FS_OPEN_READ, 0) == 0);
// Try and create a file over an already-existing file (Should fail) // Try and create a file over an already-existing file (Should fail)
SoftAssert(FSUSER_CreateFile(NULL, sdmcArchive, filePath2, 0) != 0); SoftAssert(FSUSER_CreateFile(sdmcArchive, filePath2, 0, 0) != 0);
return true; return true;
} }
static bool TestFileRename(FS_archive sdmcArchive) static bool TestFileRename(FS_Archive sdmcArchive)
{ {
Handle fileHandle; Handle fileHandle;
const static FS_path filePath = FS_makePath(PATH_CHAR, "/test_file_rename.txt"); const static FS_Path filePath = fsMakePath(PATH_ASCII, "/test_file_rename.txt");
const static FS_path newFilePath = FS_makePath(PATH_CHAR, "/test_file_rename_new.txt"); const static FS_Path newFilePath = fsMakePath(PATH_ASCII, "/test_file_rename_new.txt");
// Create file // Create file
FSUSER_CreateFile(NULL, sdmcArchive, filePath, 0); FSUSER_CreateFile(sdmcArchive, filePath, 0, 0);
SoftAssert(FSUSER_RenameFile(NULL, sdmcArchive, filePath, sdmcArchive, newFilePath) == 0); SoftAssert(FSUSER_RenameFile(sdmcArchive, filePath, sdmcArchive, newFilePath) == 0);
// Should fail to make sure the old file no longer exists // Should fail to make sure the old file no longer exists
if (FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) == 0) { if (FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, FS_OPEN_READ, 0) == 0) {
FSUSER_DeleteFile(NULL, sdmcArchive, filePath); FSUSER_DeleteFile(sdmcArchive, filePath);
return false; return false;
} }
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
// Make sure the new file exists // Make sure the new file exists
SoftAssert(FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, newFilePath, FS_OPEN_READ, 0) == 0); SoftAssert(FSUSER_OpenFile(&fileHandle, sdmcArchive, newFilePath, FS_OPEN_READ, 0) == 0);
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
SoftAssert(FSUSER_DeleteFile(NULL, sdmcArchive, newFilePath) == 0); SoftAssert(FSUSER_DeleteFile(sdmcArchive, newFilePath) == 0);
return true; return true;
} }
static bool TestFileWriteRead(FS_archive sdmcArchive) static bool TestFileWriteRead(FS_Archive sdmcArchive)
{ {
Handle fileHandle; Handle fileHandle;
u32 bytesWritten; u32 bytesWritten;
u32 bytesRead; u32 bytesRead;
u64 fileSize; u64 fileSize;
const static FS_path filePath = FS_makePath(PATH_CHAR, "/test_file_write_read.txt"); const static FS_Path filePath = fsMakePath(PATH_ASCII, "/test_file_write_read.txt");
const static char* stringWritten = "A string\n"; const static char* stringWritten = "A string\n";
// Create file // Create file
FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE | FS_OPEN_WRITE, 0); FSUSER_OpenFile(&fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE | FS_OPEN_WRITE, 0);
SCOPE_EXIT({ // Close and delete file no matter what happens SCOPE_EXIT({ // Close and delete file no matter what happens
FSFILE_Close(fileHandle); FSFILE_Close(fileHandle);
FSUSER_DeleteFile(NULL, sdmcArchive, filePath); FSUSER_DeleteFile(sdmcArchive, filePath);
}); });
// Write to file // Write to file
@ -108,65 +108,65 @@ static bool TestFileWriteRead(FS_archive sdmcArchive)
return true; return true;
} }
static bool TestDirCreateDelete(FS_archive sdmcArchive) static bool TestDirCreateDelete(FS_Archive sdmcArchive)
{ {
Handle dirHandle; Handle dirHandle;
const static FS_path dirPath = FS_makePath(PATH_CHAR, "/test_dir_create_delete"); const static FS_Path dirPath = fsMakePath(PATH_ASCII, "/test_dir_create_delete");
// Create directory // Create directory
SoftAssert(FSUSER_CreateDirectory(NULL, sdmcArchive, dirPath) == 0); SoftAssert(FSUSER_CreateDirectory(sdmcArchive, dirPath, 0) == 0);
// Make sure the new dir exists // Make sure the new dir exists
SoftAssert(FSUSER_OpenDirectory(NULL, &dirHandle, sdmcArchive, dirPath) == 0); SoftAssert(FSUSER_OpenDirectory(&dirHandle, sdmcArchive, dirPath) == 0);
FSDIR_Close(dirHandle); FSDIR_Close(dirHandle);
SoftAssert(FSUSER_DeleteDirectory(NULL, sdmcArchive, dirPath) == 0); SoftAssert(FSUSER_DeleteDirectory(sdmcArchive, dirPath) == 0);
// Should fail to make sure the dir no longer exists // Should fail to make sure the dir no longer exists
SoftAssert(FSUSER_OpenDirectory(NULL, &dirHandle, sdmcArchive, dirPath) != 0); SoftAssert(FSUSER_OpenDirectory(&dirHandle, sdmcArchive, dirPath) != 0);
FSDIR_Close(dirHandle); FSDIR_Close(dirHandle);
return true; return true;
} }
static bool TestDirRename(FS_archive sdmcArchive) static bool TestDirRename(FS_Archive sdmcArchive)
{ {
Handle dirHandle; Handle dirHandle;
const static FS_path dirPath = FS_makePath(PATH_CHAR, "/test_dir_rename"); const static FS_Path dirPath = fsMakePath(PATH_ASCII, "/test_dir_rename");
const static FS_path newDirPath = FS_makePath(PATH_CHAR, "/test_dir_rename_new"); const static FS_Path newDirPath = fsMakePath(PATH_ASCII, "/test_dir_rename_new");
// Create dir // Create dir
FSUSER_CreateDirectory(NULL, sdmcArchive, dirPath); FSUSER_CreateDirectory(sdmcArchive, dirPath, 0);
SoftAssert(FSUSER_RenameDirectory(NULL, sdmcArchive, dirPath, sdmcArchive, newDirPath) == 0); SoftAssert(FSUSER_RenameDirectory(sdmcArchive, dirPath, sdmcArchive, newDirPath) == 0);
// Should fail to make sure the old dir no longer exists // Should fail to make sure the old dir no longer exists
if (FSUSER_OpenDirectory(NULL, &dirHandle, sdmcArchive, dirPath) == 0) { if (FSUSER_OpenDirectory(&dirHandle, sdmcArchive, dirPath) == 0) {
FSUSER_DeleteDirectory(NULL, sdmcArchive, dirPath); FSUSER_DeleteDirectory(sdmcArchive, dirPath);
return false; return false;
} }
FSDIR_Close(dirHandle); FSDIR_Close(dirHandle);
// Make sure the new dir exists // Make sure the new dir exists
SoftAssert(FSUSER_OpenDirectory(NULL, &dirHandle, sdmcArchive, newDirPath) == 0); SoftAssert(FSUSER_OpenDirectory(&dirHandle, sdmcArchive, newDirPath) == 0);
FSDIR_Close(dirHandle); FSDIR_Close(dirHandle);
SoftAssert(FSUSER_DeleteDirectory(NULL, sdmcArchive, newDirPath) == 0); SoftAssert(FSUSER_DeleteDirectory(sdmcArchive, newDirPath) == 0);
return true; return true;
} }
void TestAll() void TestAll()
{ {
FS_archive sdmcArchive = { 0x00000009, { PATH_EMPTY, 1, (u8*) "" } }; FS_Archive sdmcArchive;
Test("SDMC", "Opening archive", FSUSER_OpenArchive(NULL, &sdmcArchive), 0L); Test("SDMC", "Opening archive", FSUSER_OpenArchive(&sdmcArchive, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, "")), 0L);
Test("SDMC", "Creating and deleting file", TestFileCreateDelete(sdmcArchive), true); Test("SDMC", "Creating and deleting file", TestFileCreateDelete(sdmcArchive), true);
Test("SDMC", "Renaming file", TestFileRename(sdmcArchive), true); Test("SDMC", "Renaming file", TestFileRename(sdmcArchive), true);
Test("SDMC", "Writing and reading file", TestFileWriteRead(sdmcArchive), true); Test("SDMC", "Writing and reading file", TestFileWriteRead(sdmcArchive), true);
Test("SDMC", "Creating and deleting directory", TestDirCreateDelete(sdmcArchive), true); Test("SDMC", "Creating and deleting directory", TestDirCreateDelete(sdmcArchive), true);
Test("SDMC", "Renaming directory", TestDirRename(sdmcArchive), true); Test("SDMC", "Renaming directory", TestDirRename(sdmcArchive), true);
Test("SDMC", "Closing archive", FSUSER_CloseArchive(NULL, &sdmcArchive), 0L); Test("SDMC", "Closing archive", FSUSER_CloseArchive(sdmcArchive), 0L);
} }
} // namespace } // namespace

6
source/tests/gpu/displaytransfer.cpp
View File

@ -45,9 +45,9 @@ union Dimensions {
}; };
static void DisplayTransferAndWait(u32* input, u32* output, Dimensions input_dimensions, Dimensions output_dimensions, u32 flags) { static void DisplayTransferAndWait(u32* input, u32* output, Dimensions input_dimensions, Dimensions output_dimensions, u32 flags) {
GSPGPU_FlushDataCache(nullptr, (u8*)input, sizeof(u32)); GSPGPU_FlushDataCache(input, sizeof(u32));
GSPGPU_InvalidateDataCache(nullptr, (u8*)output, sizeof(u32)); GSPGPU_InvalidateDataCache(output, sizeof(u32));
Result res = GX_SetDisplayTransfer(nullptr, (u32*)input, input_dimensions.raw, (u32*)output, output_dimensions.raw, flags); Result res = GX_DisplayTransfer(input, input_dimensions.raw, output, output_dimensions.raw, flags);
if ((u32)res != 0) { if ((u32)res != 0) {
Log(Common::FormatString("Something went wrong: %u\n", (u32)res)); Log(Common::FormatString("Something went wrong: %u\n", (u32)res));
return; return;

3
source/tests/gpu/gpu.cpp
View File

@ -6,9 +6,6 @@
namespace GPU { namespace GPU {
void TestAll() { void TestAll() {
// Initialize GPU
GPU_Init(nullptr);
DisplayTransfer::TestAll(); DisplayTransfer::TestAll();
MemoryFills::TestAll(); MemoryFills::TestAll();
} }

6
source/tests/gpu/memoryfills.cpp
View File

@ -11,13 +11,13 @@ namespace MemoryFills {
static void FillAndWait(u8* buffer, u32 value, u32 size, u32 control, bool first_engine = true) { static void FillAndWait(u8* buffer, u32 value, u32 size, u32 control, bool first_engine = true) {
if (first_engine) { if (first_engine) {
GX_SetMemoryFill(nullptr, (u32*)buffer, value, (u32*)(buffer + size), control, 0, 0, 0, 0); GX_MemoryFill((u32*)buffer, value, (u32*)(buffer + size), control, 0, 0, 0, 0);
gspWaitForPSC0(); gspWaitForPSC0();
} else { } else {
GX_SetMemoryFill(nullptr, 0, 0, 0, control, (u32*)buffer, value, (u32*)(buffer + size), control); GX_MemoryFill(0, 0, 0, control, (u32*)buffer, value, (u32*)(buffer + size), control);
gspWaitForPSC1(); gspWaitForPSC1();
} }
GSPGPU_InvalidateDataCache(nullptr, buffer, size); GSPGPU_InvalidateDataCache(buffer, size);
} }
static bool Fill32Bits(u8* buffer) { static bool Fill32Bits(u8* buffer) {

8
source/tests/kernel/waitsynch.cpp
View File

@ -1077,10 +1077,10 @@ bool Test_WaitSynch_KernelType_AddressArbiter() {
} }
void TestAll() { void TestAll() {
svcCreateEvent(&events[0], 1); svcCreateEvent(&events[0], RESET_STICKY);
svcCreateEvent(&events[1], 1); svcCreateEvent(&events[1], RESET_STICKY);
svcCreateEvent(&events[2], 1); svcCreateEvent(&events[2], RESET_STICKY);
svcCreateEvent(&events[3], 1); svcCreateEvent(&events[3], RESET_STICKY);
svcCreateMutex(&mutexes[0], false); svcCreateMutex(&mutexes[0], false);
svcCreateMutex(&mutexes[1], false); svcCreateMutex(&mutexes[1], false);