Changeset 63e27ef in mainline for kernel/arch


Ignore:
Timestamp:
2017-06-19T21:47:42Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
deacc58d
Parents:
7354b5e
Message:

ASSERT → assert

Location:
kernel/arch
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/src/ddi/ddi.c

    r7354b5e r63e27ef  
    3535#include <ddi/ddi.h>
    3636#include <arch/ddi/ddi.h>
     37#include <assert.h>
    3738#include <proc/task.h>
    3839#include <adt/bitmap.h>
    … …  
    6364       
    6465        if (elements > 0) {
    65                 ASSERT(TASK->arch.iomap.bits);
     66                assert(TASK->arch.iomap.bits);
    6667               
    6768                bitmap_t iomap;

  • kernel/arch/amd64/src/interrupt.c

    r7354b5e r63e27ef  
    3434
    3535#include <arch/interrupt.h>
     36#include <assert.h>
    3637#include <print.h>
    3738#include <log.h>
    38 #include <debug.h>
    3939#include <panic.h>
    4040#include <arch/drivers/i8259.h>
    … …  
    175175static void irq_interrupt(unsigned int n, istate_t *istate)
    176176{
    177         ASSERT(n >= IVT_IRQBASE);
     177        assert(n >= IVT_IRQBASE);
    178178       
    179179        unsigned int inum = n - IVT_IRQBASE;
    180180        bool ack = false;
    181         ASSERT(inum < IRQ_COUNT);
    182         ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     181        assert(inum < IRQ_COUNT);
     182        assert((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
    183183       
    184184        irq_t *irq = irq_dispatch_and_lock(inum);

  • kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c

    r7354b5e r63e27ef  
    3535#include <arch/exception.h>
    3636#include <arch/mach/beagleboardxm/beagleboardxm.h>
     37#include <assert.h>
    3738#include <genarch/drivers/amdm37x/uart.h>
    3839#include <genarch/drivers/amdm37x/irc.h>
    … …  
    102103            (void *) km_map(AMDM37x_IRC_BASE_ADDRESS, AMDM37x_IRC_SIZE,
    103104            PAGE_NOT_CACHEABLE);
    104         ASSERT(beagleboard.irc_addr);
     105        assert(beagleboard.irc_addr);
    105106        omap_irc_init(beagleboard.irc_addr);
    106107

  • kernel/arch/arm32/src/mach/beaglebone/beaglebone.c

    r7354b5e r63e27ef  
    3636#include <arch/exception.h>
    3737#include <arch/mach/beaglebone/beaglebone.h>
     38#include <assert.h>
    3839#include <genarch/drivers/am335x/irc.h>
    3940#include <genarch/drivers/am335x/uart.h>
    … …  
    9899            AM335x_CTRL_MODULE_SIZE, PAGE_NOT_CACHEABLE);
    99100
    100         ASSERT(bbone.irc_addr != NULL);
    101         ASSERT(bbone.cm_per_addr != NULL);
    102         ASSERT(bbone.cm_dpll_addr != NULL);
    103         ASSERT(bbone.ctrl_module != NULL);
     101        assert(bbone.irc_addr != NULL);
     102        assert(bbone.cm_per_addr != NULL);
     103        assert(bbone.cm_dpll_addr != NULL);
     104        assert(bbone.ctrl_module != NULL);
    104105
    105106        /* Initialize the interrupt controller */

  • kernel/arch/arm32/src/mach/raspberrypi/raspberrypi.c

    r7354b5e r63e27ef  
    3636#include <arch/exception.h>
    3737#include <arch/mach/raspberrypi/raspberrypi.h>
     38#include <assert.h>
    3839#include <genarch/drivers/pl011/pl011.h>
    3940#include <genarch/drivers/bcm2835/irc.h>
    … …  
    103104        raspi.irc = (void *) km_map(BCM2835_IRC_ADDR, sizeof(bcm2835_irc_t),
    104105                                    PAGE_NOT_CACHEABLE);
    105         ASSERT(raspi.irc);
     106        assert(raspi.irc);
    106107        bcm2835_irc_init(raspi.irc);
    107108

  • kernel/arch/ia32/src/ddi/ddi.c

    r7354b5e r63e27ef  
    3535#include <ddi/ddi.h>
    3636#include <arch/ddi/ddi.h>
     37#include <assert.h>
    3738#include <proc/task.h>
    3839#include <stddef.h>
    … …  
    6364       
    6465        if (elements > 0) {
    65                 ASSERT(TASK->arch.iomap.bits);
     66                assert(TASK->arch.iomap.bits);
    6667               
    6768                bitmap_t iomap;

  • kernel/arch/ia32/src/interrupt.c

    r7354b5e r63e27ef  
    3434
    3535#include <arch/interrupt.h>
     36#include <assert.h>
    3637#include <syscall/syscall.h>
    3738#include <print.h>
    … …  
    183184static void irq_interrupt(unsigned int n, istate_t *istate __attribute__((unused)))
    184185{
    185         ASSERT(n >= IVT_IRQBASE);
     186        assert(n >= IVT_IRQBASE);
    186187       
    187188        unsigned int inum = n - IVT_IRQBASE;
    188189        bool ack = false;
    189         ASSERT(inum < IRQ_COUNT);
    190         ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     190        assert(inum < IRQ_COUNT);
     191        assert((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
    191192       
    192193        irq_t *irq = irq_dispatch_and_lock(inum);

  • kernel/arch/ia32/src/smp/apic.c

    r7354b5e r63e27ef  
    3838#include <arch/smp/mps.h>
    3939#include <arch/boot/boot.h>
     40#include <assert.h>
    4041#include <mm/page.h>
    4142#include <time/delay.h>
    … …  
    492493       
    493494        /* Program Logical Destination Register. */
    494         ASSERT(CPU->id < 8);
     495        assert(CPU->id < 8);
    495496        ldr_t ldr;
    496497       

  • kernel/arch/ia32/src/smp/mps.c

    r7354b5e r63e27ef  
    3737#include <config.h>
    3838#include <log.h>
    39 #include <debug.h>
    4039#include <arch/smp/mps.h>
    4140#include <arch/smp/apic.h>
    4241#include <arch/smp/smp.h>
     42#include <assert.h>
    4343#include <func.h>
    4444#include <typedefs.h>
    … …  
    7474static uint8_t mps_cpu_apic_id(size_t i)
    7575{
    76         ASSERT(i < processor_entry_cnt);
     76        assert(i < processor_entry_cnt);
    7777       
    7878        return processor_entries[i].l_apic_id;
    … …  
    8181static bool mps_cpu_enabled(size_t i)
    8282{
    83         ASSERT(i < processor_entry_cnt);
     83        assert(i < processor_entry_cnt);
    8484       
    8585        /*
    … …  
    9696static bool mps_cpu_bootstrap(size_t i)
    9797{
    98         ASSERT(i < processor_entry_cnt);
     98        assert(i < processor_entry_cnt);
    9999       
    100100        return (bool) ((processor_entries[i].cpu_flags & 0x02) == 0x02);

  • kernel/arch/ia32/src/smp/smp.c

    r7354b5e r63e27ef  
    3838#include <arch/smp/ap.h>
    3939#include <arch/boot/boot.h>
     40#include <assert.h>
    4041#include <genarch/acpi/acpi.h>
    4142#include <genarch/acpi/madt.h>
    … …  
    4546#include <func.h>
    4647#include <panic.h>
    47 #include <debug.h>
    4848#include <arch/asm.h>
    4949#include <mm/page.h>
    … …  
    8383static void cpu_arch_id_init(void)
    8484{
    85         ASSERT(ops != NULL);
    86         ASSERT(cpus != NULL);
     85        assert(ops != NULL);
     86        assert(cpus != NULL);
    8787       
    8888        for (unsigned int i = 0; i < config.cpu_count; ++i) {
    … …  
    102102        unsigned int i;
    103103       
    104         ASSERT(ops != NULL);
     104        assert(ops != NULL);
    105105
    106106        /*
    … …  
    191191int smp_irq_to_pin(unsigned int irq)
    192192{
    193         ASSERT(ops != NULL);
     193        assert(ops != NULL);
    194194        return ops->irq_to_pin(irq);
    195195}

  • kernel/arch/ia64/include/arch/mm/page.h

    r7354b5e r63e27ef  
    3838
    3939#include <arch/mm/frame.h>
     40
     41#ifndef __ASM__
     42#include <assert.h>
     43#endif
    4044
    4145#define PAGE_SIZE   FRAME_SIZE
    … …  
    232236        uint64_t ret;
    233237       
    234         ASSERT(i < REGION_REGISTERS);
     238        assert(i < REGION_REGISTERS);
    235239       
    236240        asm volatile (
    … …  
    250254NO_TRACE static inline void rr_write(size_t i, uint64_t v)
    251255{
    252         ASSERT(i < REGION_REGISTERS);
     256        assert(i < REGION_REGISTERS);
    253257       
    254258        asm volatile (

  • kernel/arch/ia64/src/drivers/ski.c

    r7354b5e r63e27ef  
    3434
    3535#include <arch/drivers/ski.h>
     36#include <assert.h>
    3637#include <console/console.h>
    3738#include <console/chardev.h>
    … …  
    238239void skiin_wire(ski_instance_t *instance, indev_t *srlnin)
    239240{
    240         ASSERT(instance);
    241         ASSERT(srlnin);
     241        assert(instance);
     242        assert(srlnin);
    242243       
    243244        instance->srlnin = srlnin;

  • kernel/arch/ia64/src/interrupt.c

    r7354b5e r63e27ef  
    3535
    3636#include <arch/interrupt.h>
     37#include <assert.h>
    3738#include <interrupt.h>
    3839#include <ddi/irq.h>
    3940#include <panic.h>
    4041#include <print.h>
    41 #include <debug.h>
    4242#include <console/console.h>
    4343#include <typedefs.h>
    … …  
    123123static const char *vector_to_string(unsigned int n)
    124124{
    125         ASSERT(n <= VECTOR_MAX);
     125        assert(n <= VECTOR_MAX);
    126126       
    127127        if (n >= VECTORS_16_BUNDLE_START)

  • kernel/arch/ia64/src/mm/as.c

    r7354b5e r63e27ef  
    3636#include <arch/mm/asid.h>
    3737#include <arch/mm/page.h>
     38#include <assert.h>
    3839#include <genarch/mm/as_ht.h>
    3940#include <genarch/mm/page_ht.h>
    … …  
    5859        int i;
    5960       
    60         ASSERT(as->asid != ASID_INVALID);
     61        assert(as->asid != ASID_INVALID);
    6162       
    6263        /*

  • kernel/arch/ia64/src/mm/page.c

    r7354b5e r63e27ef  
    3535
    3636#include <arch/mm/page.h>
     37#include <assert.h>
    3738#include <genarch/mm/page_ht.h>
    3839#include <mm/asid.h>
    … …  
    166167        bool match;
    167168
    168         ASSERT(v);
     169        assert(v);
    169170
    170171        vrn = page >> VRN_SHIFT;
    … …  
    213214        uint64_t tag;
    214215
    215         ASSERT(v);
     216        assert(v);
    216217
    217218        vrn = page >> VRN_SHIFT;

  • kernel/arch/ia64/src/mm/tlb.c

    r7354b5e r63e27ef  
    4848#include <arch/pal/pal.h>
    4949#include <arch/asm.h>
     50#include <assert.h>
    5051#include <panic.h>
    5152#include <print.h>
    … …  
    449450        entry.word[1] = 0;
    450451       
    451         ASSERT(t->x);
     452        assert(t->x);
    452453       
    453454        entry.p = t->p;
    … …  
    488489        va = istate->cr_ifa; /* faulting address */
    489490       
    490         ASSERT(!is_kernel_fault(va));
     491        assert(!is_kernel_fault(va));
    491492
    492493        bool found = page_mapping_find(AS, va, true, &t);
    493494        if (found) {
    494                 ASSERT(t.p);
     495                assert(t.p);
    495496
    496497                /*
    … …  
    605606        bool found = page_mapping_find(as, va, true, &t);
    606607        if (found) {
    607                 ASSERT(t.p);
     608                assert(t.p);
    608609
    609610                /*
    … …  
    634635void data_nested_tlb_fault(unsigned int n, istate_t *istate)
    635636{
    636         ASSERT(false);
     637        assert(false);
    637638}
    638639
    … …  
    656657        bool found = page_mapping_find(as, va, true, &t);
    657658
    658         ASSERT(found);
    659         ASSERT(t.p);
     659        assert(found);
     660        assert(t.p);
    660661
    661662        if (found && t.p && t.w) {
    … …  
    685686        va = istate->cr_ifa;  /* faulting address */
    686687
    687         ASSERT(!is_kernel_fault(va));
     688        assert(!is_kernel_fault(va));
    688689       
    689690        bool found = page_mapping_find(AS, va, true, &t);
    690691
    691         ASSERT(found);
    692         ASSERT(t.p);
     692        assert(found);
     693        assert(t.p);
    693694
    694695        if (found && t.p && t.x) {
    … …  
    724725        bool found = page_mapping_find(as, va, true, &t);
    725726
    726         ASSERT(found);
    727         ASSERT(t.p);
     727        assert(found);
     728        assert(t.p);
    728729
    729730        if (found && t.p) {
    … …  
    757758        va = istate->cr_ifa;  /* faulting address */
    758759
    759         ASSERT(!is_kernel_fault(va));
     760        assert(!is_kernel_fault(va));
    760761       
    761762        /*
    … …  
    764765        bool found = page_mapping_find(AS, va, true, &t);
    765766
    766         ASSERT(found);
    767         ASSERT(t.p);
    768         ASSERT(!t.w);
     767        assert(found);
     768        assert(t.p);
     769        assert(!t.w);
    769770
    770771        as_page_fault(va, PF_ACCESS_WRITE, istate);
    … …  
    784785        va = istate->cr_ifa;  /* faulting address */
    785786       
    786         ASSERT(!is_kernel_fault(va));
     787        assert(!is_kernel_fault(va));
    787788
    788789        bool found = page_mapping_find(AS, va, true, &t);
    789790
    790         ASSERT(found);
     791        assert(found);
    791792       
    792793        if (t.p) {

  • kernel/arch/mips32/src/exception.c

    r7354b5e r63e27ef  
    3939#include <arch/cp0.h>
    4040#include <arch.h>
    41 #include <debug.h>
     41#include <assert.h>
    4242#include <proc/thread.h>
    4343#include <print.h>
    … …  
    120120{
    121121        if (*((uint32_t *) istate->epc) == 0x7c03e83b) {
    122                 ASSERT(THREAD);
     122                assert(THREAD);
    123123                istate->epc += 4;
    124124                istate->v1 = istate->kt1;

  • kernel/arch/mips32/src/mm/tlb.c

    r7354b5e r63e27ef  
    4444#include <print.h>
    4545#include <log.h>
    46 #include <debug.h>
     46#include <assert.h>
    4747#include <align.h>
    4848#include <interrupt.h>
    … …  
    160160#endif
    161161
    162         ASSERT(!index.p);
     162        assert(!index.p);
    163163
    164164        badvaddr = cp0_badvaddr_read();
    … …  
    323323        int i;
    324324
    325         ASSERT(interrupts_disabled());
     325        assert(interrupts_disabled());
    326326
    327327        hi_save.value = cp0_entry_hi_read();
    … …  
    356356        int i;
    357357
    358         ASSERT(interrupts_disabled());
    359         ASSERT(asid != ASID_INVALID);
     358        assert(interrupts_disabled());
     359        assert(asid != ASID_INVALID);
    360360
    361361        hi_save.value = cp0_entry_hi_read();
    … …  
    398398        tlb_index_t index;
    399399
    400         ASSERT(interrupts_disabled());
     400        assert(interrupts_disabled());
    401401       
    402402        if (asid == ASID_INVALID)

  • kernel/arch/ppc32/src/mm/pht.c

    r7354b5e r63e27ef  
    3535#include <arch/mm/pht.h>
    3636#include <arch/mm/tlb.h>
     37#include <assert.h>
    3738#include <interrupt.h>
    3839#include <mm/as.h>
    … …  
    7980                found = page_mapping_find(as, badvaddr, true, pte);
    8081
    81                 ASSERT(found);
    82                 ASSERT(pte->present);
     82                assert(found);
     83                assert(pte->present);
    8384
    8485                return found;

  • kernel/arch/sparc64/src/drivers/pci.c

    r7354b5e r63e27ef  
    4242#include <mm/slab.h>
    4343#include <typedefs.h>
    44 #include <debug.h>
     44#include <assert.h>
    4545#include <log.h>
    4646#include <str.h>
    … …  
    175175         * First, verify this is a PCI node.
    176176         */
    177         ASSERT(str_cmp(ofw_tree_node_name(node), "pci") == 0);
     177        assert(str_cmp(ofw_tree_node_name(node), "pci") == 0);
    178178
    179179        /*
    … …  
    210210void pci_enable_interrupt(pci_t *pci, int inr)
    211211{
    212         ASSERT(pci->op && pci->op->enable_interrupt);
     212        assert(pci->op && pci->op->enable_interrupt);
    213213        pci->op->enable_interrupt(pci, inr);
    214214}
    … …  
    218218        pci_t *pci = (pci_t *)pcip;
    219219
    220         ASSERT(pci->op && pci->op->clear_interrupt);
     220        assert(pci->op && pci->op->clear_interrupt);
    221221        pci->op->clear_interrupt(pci, inr);
    222222}

  • kernel/arch/sparc64/src/drivers/tick.c

    r7354b5e r63e27ef  
    4343#include <time/clock.h>
    4444#include <arch.h>
    45 #include <debug.h>
     45#include <assert.h>
    4646
    4747/** Initialize tick and stick interrupt. */
    … …  
    9393         * Make sure we are servicing interrupt_level_14
    9494         */
    95         ASSERT(n == TT_INTERRUPT_LEVEL_14);
     95        assert(n == TT_INTERRUPT_LEVEL_14);
    9696       
    9797        /*
    9898         * Make sure we are servicing TICK_INT.
    9999         */
    100         ASSERT(softint.tick_int);
     100        assert(softint.tick_int);
    101101
    102102        /*

  • kernel/arch/sparc64/src/mm/sun4u/as.c

    r7354b5e r63e27ef  
    3535#include <arch/mm/as.h>
    3636#include <arch/mm/tlb.h>
     37#include <assert.h>
     38#include <config.h>
    3739#include <genarch/mm/page_ht.h>
    3840#include <genarch/mm/asid_fifo.h>
    39 #include <debug.h>
    40 #include <config.h>
    4141
    4242#ifdef CONFIG_TSB
    … …  
    130130        uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    131131       
    132         ASSERT(as->arch.itsb);
    133         ASSERT(as->arch.dtsb);
     132        assert(as->arch.itsb);
     133        assert(as->arch.dtsb);
    134134       
    135135        uintptr_t tsb = (uintptr_t) as->arch.itsb;
    … …  
    202202        uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    203203       
    204         ASSERT(as->arch.itsb);
    205         ASSERT(as->arch.dtsb);
     204        assert(as->arch.itsb);
     205        assert(as->arch.dtsb);
    206206       
    207207        uintptr_t tsb = (uintptr_t) as->arch.itsb;

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r7354b5e r63e27ef  
    4141#include <arch/mm/mmu.h>
    4242#include <arch/interrupt.h>
     43#include <assert.h>
    4344#include <interrupt.h>
    4445#include <arch.h>
    … …  
    201202        bool found = page_mapping_find(AS, istate->tpc, true, &t);
    202203        if (found && PTE_EXECUTABLE(&t)) {
    203                 ASSERT(t.p);
     204                assert(t.p);
    204205
    205206                /*
    … …  
    258259        bool found = page_mapping_find(as, page_16k, true, &t);
    259260        if (found) {
    260                 ASSERT(t.p);
     261                assert(t.p);
    261262
    262263                /*
    … …  
    301302        bool found = page_mapping_find(as, page_16k, true, &t);
    302303        if (found && PTE_WRITABLE(&t)) {
    303                 ASSERT(t.p);
     304                assert(t.p);
    304305
    305306                /*

  • kernel/arch/sparc64/src/mm/sun4u/tsb.c

    r7354b5e r63e27ef  
    2727 */
    2828
    29 /** @addtogroup sparc64mm       
     29/** @addtogroup sparc64mm
    3030 * @{
    3131 */
    … …  
    3737#include <arch/mm/page.h>
    3838#include <arch/barrier.h>
     39#include <assert.h>
    3940#include <mm/as.h>
    4041#include <typedefs.h>
    4142#include <macros.h>
    42 #include <debug.h>
    4343
    4444/** Invalidate portion of TSB.
    … …  
    5858        size_t cnt;
    5959       
    60         ASSERT(as->arch.itsb);
    61         ASSERT(as->arch.dtsb);
     60        assert(as->arch.itsb);
     61        assert(as->arch.dtsb);
    6262       
    6363        i0 = (page >> MMU_PAGE_WIDTH) & ITSB_ENTRY_MASK;
    … …  
    8585        size_t entry;
    8686
    87         ASSERT(index <= 1);
     87        assert(index <= 1);
    8888       
    8989        as = t->as;
    … …  
    130130        size_t entry;
    131131       
    132         ASSERT(index <= 1);
     132        assert(index <= 1);
    133133
    134134        as = t->as;

  • kernel/arch/sparc64/src/mm/sun4v/as.c

    r7354b5e r63e27ef  
    3737#include <arch/mm/pagesize.h>
    3838#include <arch/mm/tlb.h>
     39#include <assert.h>
    3940#include <genarch/mm/page_ht.h>
    4041#include <genarch/mm/asid_fifo.h>
    41 #include <debug.h>
    4242#include <config.h>
    4343#include <arch/sun4v/hypercall.h>
    … …  
    121121        uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    122122       
    123         ASSERT(as->arch.tsb_description.tsb_base);
     123        assert(as->arch.tsb_description.tsb_base);
    124124        uintptr_t tsb = PA2KA(as->arch.tsb_description.tsb_base);
    125125       
    … …  
    160160        uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    161161       
    162         ASSERT(as->arch.tsb_description.tsb_base);
     162        assert(as->arch.tsb_description.tsb_base);
    163163       
    164164        uintptr_t tsb = PA2KA(as->arch.tsb_description.tsb_base);

  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r7354b5e r63e27ef  
    4343#include <arch/mm/tlb.h>
    4444#include <arch/interrupt.h>
     45#include <assert.h>
    4546#include <interrupt.h>
    4647#include <arch.h>
    … …  
    215216        bool found = page_mapping_find(AS, va, true, &t);
    216217        if (found && PTE_EXECUTABLE(&t)) {
    217                 ASSERT(t.p);
     218                assert(t.p);
    218219
    219220                /*
    … …  
    265266        bool found = page_mapping_find(as, va, true, &t);
    266267        if (found) {
    267                 ASSERT(t.p);
     268                assert(t.p);
    268269
    269270                /*
    … …  
    303304        bool found = page_mapping_find(as, va, true, &t);
    304305        if (found && PTE_WRITABLE(&t)) {
    305                 ASSERT(t.p);
     306                assert(t.p);
    306307
    307308                /*
    … …  
    345346        __hypercall_fast_ret1(0, 0, 0, 0, 0, CPU_MYID, &myid);
    346347
    347         ASSERT(mmu_fsas[myid].dft < 16);
     348        assert(mmu_fsas[myid].dft < 16);
    348349
    349350        printf("condition which caused the fault: %s\n",

  • kernel/arch/sparc64/src/mm/sun4v/tsb.c

    r7354b5e r63e27ef  
    3939#include <arch/mm/page.h>
    4040#include <arch/barrier.h>
     41#include <assert.h>
    4142#include <mm/as.h>
    4243#include <typedefs.h>
    4344#include <macros.h>
    44 #include <debug.h>
    4545
    4646/** Invalidate portion of TSB.
    … …  
    6060        size_t cnt;
    6161       
    62         ASSERT(as->arch.tsb_description.tsb_base);
     62        assert(as->arch.tsb_description.tsb_base);
    6363       
    6464        i0 = (page >> MMU_PAGE_WIDTH) & TSB_ENTRY_MASK;

  • kernel/arch/sparc64/src/smp/sun4u/ipi.c

    r7354b5e r63e27ef  
    3535#include <smp/ipi.h>
    3636#include <arch/smp/sun4u/ipi.h>
     37#include <assert.h>
    3738#include <cpu.h>
    3839#include <arch.h>
    … …  
    103104                panic("Interrupt Dispatch Status busy bit set\n");
    104105       
    105         ASSERT(!(pstate_read() & PSTATE_IE_BIT));
     106        assert(!(pstate_read() & PSTATE_IE_BIT));
    106107       
    107108        do {
    … …  
    185186void ipi_unicast_arch(unsigned int cpu_id, int ipi)
    186187{
    187         ASSERT(&cpus[cpu_id] != CPU);
     188        assert(&cpus[cpu_id] != CPU);
    188189       
    189190        if (ipi == IPI_SMP_CALL) {

  • kernel/arch/sparc64/src/sparc64.c

    r7354b5e r63e27ef  
    7070
    7171        if (config.cpu_active == 1) {
    72                 STATIC_ASSERT(UWB_SIZE <= UWB_ALIGNMENT);
     72                static_assert(UWB_SIZE <= UWB_ALIGNMENT, "");
    7373                /* Create slab cache for the userspace window buffers */
    7474                uwb_cache = slab_cache_create("uwb_cache", UWB_SIZE,
Note: See TracChangeset for help on using the changeset viewer.