[Git][ghc/ghc][master] 2 commits: rts: Use CHECK instead of assert
Marge Bot
gitlab at gitlab.haskell.org
Mon Nov 30 15:16:07 UTC 2020
Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC
Commits:
b6629289 by Ben Gamari at 2020-11-30T10:15:58-05:00
rts: Use CHECK instead of assert
Use the GHC wrappers instead of <assert.h>.
- - - - -
9f4efa6a by Ben Gamari at 2020-11-30T10:15:58-05:00
rts/linker: Replace some ASSERTs with CHECK
In the past some people have confused ASSERT, which is for checking
internal invariants, which CHECK, which should be used when checking
things that might fail due to bad input (and therefore should be enabled
even in the release compiler). Change some of these cases in the linker
to use CHECK.
- - - - -
7 changed files:
- rts/Linker.c
- rts/linker/Elf.c
- rts/linker/MachO.c
- rts/linker/PEi386.c
- rts/linker/elf_got.c
- rts/linker/elf_reloc_aarch64.c
- rts/win32/veh_excn.c
Changes:
=====================================
rts/Linker.c
=====================================
@@ -49,7 +49,6 @@
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
-#include <assert.h>
#include <fs_rts.h>
#if defined(HAVE_SYS_STAT_H)
@@ -885,12 +884,11 @@ SymbolAddr* lookupDependentSymbol (SymbolName* lbl, ObjectCode *dependent)
*/
IF_DEBUG(linker, debugBelch("lookupSymbol: looking up %s with dlsym\n",
lbl));
- ASSERT(lbl[0] == '_');
+ CHECK(lbl[0] == '_');
return internal_dlsym(lbl + 1);
# else
- ASSERT(false);
- return NULL;
+# error No OBJFORMAT_* macro set
# endif
} else {
if (dependent) {
@@ -2112,7 +2110,7 @@ HsInt unloadNativeObj (void *handle)
n_unloaded_objects += 1;
// dynamic objects have no symbols
- ASSERT(nc->symbols == NULL);
+ CHECK(nc->symbols == NULL);
freeOcStablePtrs(nc);
// Remove object code from root set
=====================================
rts/linker/Elf.c
=====================================
@@ -416,7 +416,7 @@ ocVerifyImage_ELF ( ObjectCode* oc )
"\nSection header table: start %ld, n_entries %d, ent_size %d\n",
(long)ehdr->e_shoff, shnum, ehdr->e_shentsize ));
- ASSERT(ehdr->e_shentsize == sizeof(Elf_Shdr));
+ CHECK(ehdr->e_shentsize == sizeof(Elf_Shdr));
shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
@@ -537,7 +537,7 @@ ocVerifyImage_ELF ( ObjectCode* oc )
#if defined(SHN_XINDEX)
/* See Note [Many ELF Sections] */
if (secno == SHN_XINDEX) {
- ASSERT(shndxTable);
+ CHECK(shndxTable);
secno = shndxTable[j];
}
#endif
@@ -864,7 +864,7 @@ ocGetNames_ELF ( ObjectCode* oc )
PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE,
-1, 0);
- ASSERT(common_mem != NULL);
+ CHECK(common_mem != NULL);
}
//TODO: we ignore local symbols anyway right? So we can use the
@@ -893,7 +893,7 @@ ocGetNames_ELF ( ObjectCode* oc )
secno = shndx;
#if defined(SHN_XINDEX)
if (shndx == SHN_XINDEX) {
- ASSERT(shndxTable);
+ CHECK(shndxTable);
secno = shndxTable[j];
}
#endif
@@ -902,11 +902,11 @@ ocGetNames_ELF ( ObjectCode* oc )
if (shndx == SHN_COMMON) {
isLocal = false;
- ASSERT(common_used < common_size);
- ASSERT(common_mem);
+ CHECK(common_used < common_size);
+ CHECK(common_mem);
symbol->addr = (void*)((uintptr_t)common_mem + common_used);
common_used += symbol->elf_sym->st_size;
- ASSERT(common_used <= common_size);
+ CHECK(common_used <= common_size);
IF_DEBUG(linker,
debugBelch("COMMON symbol, size %ld name %s allocated at %p\n",
@@ -935,7 +935,7 @@ ocGetNames_ELF ( ObjectCode* oc )
)
) {
/* Section 0 is the undefined section, hence > and not >=. */
- ASSERT(secno > 0 && secno < shnum);
+ CHECK(secno > 0 && secno < shnum);
/*
if (shdr[secno].sh_type == SHT_NOBITS) {
debugBelch(" BSS symbol, size %d off %d name %s\n",
@@ -945,7 +945,7 @@ ocGetNames_ELF ( ObjectCode* oc )
symbol->addr = (SymbolAddr*)(
(intptr_t) oc->sections[secno].start +
(intptr_t) symbol->elf_sym->st_value);
- ASSERT(symbol->addr != 0x0);
+ CHECK(symbol->addr != 0x0);
if (ELF_ST_BIND(symbol->elf_sym->st_info) == STB_LOCAL) {
isLocal = true;
isWeak = false;
@@ -962,7 +962,7 @@ ocGetNames_ELF ( ObjectCode* oc )
/* And the decision is ... */
if (symbol->addr != NULL) {
- ASSERT(nm != NULL);
+ CHECK(nm != NULL);
/* Acquire! */
if (!isLocal) {
@@ -1045,7 +1045,7 @@ do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
break;
}
}
- ASSERT(stab != NULL);
+ CHECK(stab != NULL);
targ = (Elf_Word*)oc->sections[target_shndx].start;
IF_DEBUG(linker,debugBelch(
@@ -1251,7 +1251,7 @@ do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
result = ((S + A) | T) - P;
result &= ~1; // Clear thumb indicator bit
- ASSERT(isInt(26, result)); /* X in range */
+ CHECK(isInt(26, result)); /* X in range */
}
// Update the branch target
@@ -1426,7 +1426,7 @@ do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
case COMPAT_R_ARM_GOT_PREL: {
int32_t A = *pP;
void* GOT_S = symbol->got_addr;
- ASSERT(GOT_S);
+ CHECK(GOT_S);
*(uint32_t *)P = (uint32_t) GOT_S + A - P;
break;
}
@@ -1552,21 +1552,21 @@ do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC,
case R_SPARC_WDISP30:
w1 = *pP & 0xC0000000;
w2 = (Elf_Word)((value - P) >> 2);
- ASSERT((w2 & 0xC0000000) == 0);
+ CHECK((w2 & 0xC0000000) == 0);
w1 |= w2;
*pP = w1;
break;
case R_SPARC_HI22:
w1 = *pP & 0xFFC00000;
w2 = (Elf_Word)(value >> 10);
- ASSERT((w2 & 0xFFC00000) == 0);
+ CHECK((w2 & 0xFFC00000) == 0);
w1 |= w2;
*pP = w1;
break;
case R_SPARC_LO10:
w1 = *pP & ~0x3FF;
w2 = (Elf_Word)(value & 0x3FF);
- ASSERT((w2 & ~0x3FF) == 0);
+ CHECK((w2 & ~0x3FF) == 0);
w1 |= w2;
*pP = w1;
break;
@@ -1866,13 +1866,13 @@ ocResolve_ELF ( ObjectCode* oc )
Elf_Word secno = symbol->elf_sym->st_shndx;
#if defined(SHN_XINDEX)
if (secno == SHN_XINDEX) {
- ASSERT(shndxTable);
+ CHECK(shndxTable);
secno = shndxTable[i];
}
#endif
- ASSERT(symbol->elf_sym->st_name == 0);
- ASSERT(symbol->elf_sym->st_value == 0);
- ASSERT(0x0 != oc->sections[ secno ].start);
+ CHECK(symbol->elf_sym->st_name == 0);
+ CHECK(symbol->elf_sym->st_value == 0);
+ CHECK(0x0 != oc->sections[ secno ].start);
symbol->addr = oc->sections[ secno ].start;
}
}
@@ -1946,7 +1946,7 @@ int ocRunInit_ELF( ObjectCode *oc )
init_start = (init_t*)init_startC;
init_end = (init_t*)(init_startC + shdr[i].sh_size);
for (init = init_start; init < init_end; init++) {
- ASSERT(0x0 != *init);
+ CHECK(0x0 != *init);
(*init)(argc, argv, envv);
}
}
=====================================
rts/linker/MachO.c
=====================================
@@ -252,7 +252,6 @@ resolveImports(
"%s: unknown symbol `%s'", oc->fileName, symbol->name);
return 0;
}
- ASSERT(addr);
checkProddableBlock(oc,
((void**)(oc->image + sect->offset)) + i,
@@ -847,7 +846,7 @@ relocateSection(ObjectCode* oc, int curSection)
IF_DEBUG(linker, debugBelch(" : value = %p\n", (void *)symbol->nlist->n_value));
if ((symbol->nlist->n_type & N_TYPE) == N_SECT) {
- ASSERT(symbol->addr != NULL);
+ CHECK(symbol->addr != NULL);
value = (uint64_t) symbol->addr;
IF_DEBUG(linker, debugBelch("relocateSection, defined external symbol %s, relocated address %p\n",
nm, (void *)value));
@@ -949,29 +948,29 @@ relocateSection(ObjectCode* oc, int curSection)
{
if((int32_t)(value - baseValue) != (int64_t)(value - baseValue))
{
- ASSERT(reloc->r_extern);
+ CHECK(reloc->r_extern);
value = (uint64_t) &makeSymbolExtra(oc, reloc->r_symbolnum, value)
-> jumpIsland;
}
- ASSERT((int32_t)(value - baseValue) == (int64_t)(value - baseValue));
+ CHECK((int32_t)(value - baseValue) == (int64_t)(value - baseValue));
type = X86_64_RELOC_SIGNED;
}
switch(type)
{
case X86_64_RELOC_UNSIGNED:
- ASSERT(!reloc->r_pcrel);
+ CHECK(!reloc->r_pcrel);
thing += value;
break;
case X86_64_RELOC_SIGNED:
case X86_64_RELOC_SIGNED_1:
case X86_64_RELOC_SIGNED_2:
case X86_64_RELOC_SIGNED_4:
- ASSERT(reloc->r_pcrel);
+ CHECK(reloc->r_pcrel);
thing += value - baseValue;
break;
case X86_64_RELOC_SUBTRACTOR:
- ASSERT(!reloc->r_pcrel);
+ CHECK(!reloc->r_pcrel);
thing -= value;
break;
default:
=====================================
rts/linker/PEi386.c
=====================================
@@ -1594,7 +1594,7 @@ ocGetNames_PEi386 ( ObjectCode* oc )
barf ("Could not allocate any heap memory from private heap.");
}
- ASSERT(section.size == 0 || section.info->virtualSize == 0);
+ CHECK(section.size == 0 || section.info->virtualSize == 0);
sz = section.size;
if (sz < section.info->virtualSize) sz = section.info->virtualSize;
@@ -2032,7 +2032,7 @@ ocRunInit_PEi386 ( ObjectCode *oc )
getProgEnvv(&envc, &envv);
Section section = *oc->info->init;
- ASSERT(SECTIONKIND_INIT_ARRAY == section.kind);
+ CHECK(SECTIONKIND_INIT_ARRAY == section.kind);
uint8_t *init_startC = section.start;
init_t *init_start = (init_t*)init_startC;
=====================================
rts/linker/elf_got.c
=====================================
@@ -136,10 +136,10 @@ verifyGot(ObjectCode * oc) {
for(size_t i=0; i < symTab->n_symbols; i++) {
ElfSymbol * symbol = &symTab->symbols[i];
if(symbol->got_addr) {
- ASSERT((void*)(*(void**)symbol->got_addr)
- == (void*)symbol->addr);
+ CHECK((void*)(*(void**)symbol->got_addr)
+ == (void*)symbol->addr);
}
- ASSERT(0 == ((uintptr_t)symbol->addr & 0xffff000000000000));
+ CHECK(0 == ((uintptr_t)symbol->addr & 0xffff000000000000));
}
}
return EXIT_SUCCESS;
=====================================
rts/linker/elf_reloc_aarch64.c
=====================================
@@ -6,7 +6,6 @@
#include "elf_plt.h"
#include <stdlib.h>
-#include <assert.h>
#if defined(aarch64_HOST_ARCH)
@@ -71,15 +70,15 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
*(uint64_t*)P = (uint64_t)addend;
break;
case COMPAT_R_AARCH64_ABS32:
- assert(isInt64(32, addend));
+ CHECK(isInt64(32, addend));
case COMPAT_R_AARCH64_PREL32:
- assert(isInt64(32, addend));
+ CHECK(isInt64(32, addend));
*(uint32_t*)P = (uint32_t)addend;
break;
case COMPAT_R_AARCH64_ABS16:
- assert(isInt64(16, addend));
+ CHECK(isInt64(16, addend));
case COMPAT_R_AARCH64_PREL16:
- assert(isInt64(16, addend));
+ CHECK(isInt64(16, addend));
*(uint16_t*)P = (uint16_t)addend;
break;
/* static aarch64 relocations */
@@ -95,8 +94,8 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
// imm64 = SignExtend(hi:lo:0x000,64)
// Range is 21 bits + the 12 page relative bits
// known to be 0. -2^32 <= X < 2^32
- assert(isInt64(21+12, addend));
- assert((addend & 0xfff) == 0); /* page relative */
+ CHECK(isInt64(21+12, addend));
+ CHECK((addend & 0xfff) == 0); /* page relative */
*(inst_t *)P = (*(inst_t *)P & 0x9f00001f)
| (inst_t) (((uint64_t) addend << 17) & 0x60000000)
@@ -106,7 +105,7 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
/* - control flow relocations */
case COMPAT_R_AARCH64_JUMP26: /* relocate b ... */
case COMPAT_R_AARCH64_CALL26: { /* relocate bl ... */
- assert(isInt64(26+2, addend)); /* X in range */
+ CHECK(isInt64(26+2, addend)); /* X in range */
*(inst_t *)P = (*(inst_t *)P & 0xfc000000) /* keep upper 6 (32-6)
* bits */
| ((uint32_t)(addend >> 2) & 0x03ffffff);
@@ -114,8 +113,8 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
}
case COMPAT_R_AARCH64_ADR_GOT_PAGE: {
/* range is -2^32 <= X < 2^32 */
- assert(isInt64(21+12, addend)); /* X in range */
- assert((addend & 0xfff) == 0); /* page relative */
+ CHECK(isInt64(21+12, addend)); /* X in range */
+ CHECK((addend & 0xfff) == 0); /* page relative */
*(inst_t *)P = (*(inst_t *)P & 0x9f00001f)
| (inst_t)(((uint64_t)addend << 17) & 0x60000000) // lo
@@ -149,10 +148,10 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
FALLTHROUGH;
case COMPAT_R_AARCH64_LD64_GOT_LO12_NC: {
if(exp_shift == -1) {
- assert( (addend & 7) == 0 );
+ CHECK( (addend & 7) == 0 );
exp_shift = 3;
}
- assert((addend & 0xfff) == addend);
+ CHECK((addend & 0xfff) == addend);
int shift = 0;
if(isLoadStore(P)) {
/* bits 31, 30 encode the size. */
@@ -161,7 +160,7 @@ encodeAddendAarch64(Section * section, Elf_Rel * rel, int64_t addend) {
shift = 4;
}
}
- assert(addend == 0 || exp_shift == shift);
+ CHECK(addend == 0 || exp_shift == shift);
*(inst_t *)P = (*(inst_t *)P & 0xffc003ff)
| ((inst_t)(addend >> shift << 10) & 0x003ffc00);
break;
@@ -188,12 +187,12 @@ computeAddend(Section * section, Elf_Rel * rel,
/* Position where something is relocated */
addr_t P = (addr_t)((uint8_t*)section->start + rel->r_offset);
- assert(0x0 != P);
- assert((uint64_t)section->start <= P);
- assert(P <= (uint64_t)section->start + section->size);
+ CHECK(0x0 != P);
+ CHECK((uint64_t)section->start <= P);
+ CHECK(P <= (uint64_t)section->start + section->size);
/* Address of the symbol */
addr_t S = (addr_t) symbol->addr;
- assert(0x0 != S);
+ CHECK(0x0 != S);
/* GOT slot for the symbol */
addr_t GOT_S = (addr_t) symbol->got_addr;
@@ -243,16 +242,16 @@ computeAddend(Section * section, Elf_Rel * rel,
}
}
- assert(0 == (0xffff000000000000 & S));
+ CHECK(0 == (0xffff000000000000 & S));
V = S + A - P;
- assert(isInt64(26+2, V)); /* X in range */
+ CHECK(isInt64(26+2, V)); /* X in range */
}
return V;
}
- case COMPAT_R_AARCH64_LDST128_ABS_LO12_NC: assert(0 == ((S+A) & 0x0f));
- case COMPAT_R_AARCH64_LDST64_ABS_LO12_NC: assert(0 == ((S+A) & 0x07));
- case COMPAT_R_AARCH64_LDST32_ABS_LO12_NC: assert(0 == ((S+A) & 0x03));
- case COMPAT_R_AARCH64_LDST16_ABS_LO12_NC: assert(0 == ((S+A) & 0x01));
+ case COMPAT_R_AARCH64_LDST128_ABS_LO12_NC: CHECK(0 == ((S+A) & 0x0f));
+ case COMPAT_R_AARCH64_LDST64_ABS_LO12_NC: CHECK(0 == ((S+A) & 0x07));
+ case COMPAT_R_AARCH64_LDST32_ABS_LO12_NC: CHECK(0 == ((S+A) & 0x03));
+ case COMPAT_R_AARCH64_LDST16_ABS_LO12_NC: CHECK(0 == ((S+A) & 0x01));
case COMPAT_R_AARCH64_LDST8_ABS_LO12_NC:
/* type: static, class: aarch64, op: S + A */
return (S + A) & 0xfff;
@@ -266,12 +265,12 @@ computeAddend(Section * section, Elf_Rel * rel,
// TODO: fix this story proper, so that the transformation
// makes sense without resorting to: everyone else
// does it like this as well.
- assert(0x0 != GOT_S);
+ CHECK(0x0 != GOT_S);
return Page(GOT_S+A) - Page(P);
}
case COMPAT_R_AARCH64_LD64_GOT_LO12_NC: {
// G(GDAT(S+A))
- assert(0x0 != GOT_S);
+ CHECK(0x0 != GOT_S);
return (GOT_S + A) & 0xfff;
}
default:
@@ -297,7 +296,7 @@ relocateObjectCodeAarch64(ObjectCode * oc) {
relTab->sectionHeader->sh_link,
ELF64_R_SYM((Elf64_Xword)rel->r_info));
- assert(0x0 != symbol);
+ CHECK(0x0 != symbol);
/* decode implicit addend */
int64_t addend = decodeAddendAarch64(targetSection, rel);
@@ -323,8 +322,8 @@ relocateObjectCodeAarch64(ObjectCode * oc) {
relaTab->sectionHeader->sh_link,
ELF64_R_SYM((Elf64_Xword)rel->r_info));
- assert(0x0 != symbol);
- assert(0x0 != symbol->addr);
+ CHECK(0x0 != symbol);
+ CHECK(0x0 != symbol->addr);
/* take explicit addend */
int64_t addend = rel->r_addend;
=====================================
rts/win32/veh_excn.c
=====================================
@@ -10,7 +10,6 @@
#include "ghcconfig.h"
#include "veh_excn.h"
#include "LinkerInternals.h"
-#include <assert.h>
#include <stdbool.h>
#include <dbghelp.h>
#include <shellapi.h>
@@ -195,7 +194,7 @@ void __register_hs_exception_handler( void )
__hs_handle = AddVectoredContinueHandler(CALL_LAST,
__hs_exception_handler);
// should the handler not be registered this will return a null.
- assert(__hs_handle);
+ CHECK(__hs_handle);
// Register for an exception filter to ensure the continue handler gets
// hit if no one handled the exception.
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/8d304a99d2d0c17fb49c0589c0525817d515c0d0...9f4efa6a5e5d43c81d7e61b27f7cd6e3f812b1ea
--
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/8d304a99d2d0c17fb49c0589c0525817d515c0d0...9f4efa6a5e5d43c81d7e61b27f7cd6e3f812b1ea
You're receiving this email because of your account on gitlab.haskell.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-commits/attachments/20201130/80806d5d/attachment-0001.html>
More information about the ghc-commits
mailing list