Merge pull request erlang#9421 from jhogberg/john/erts/spring-cleaning

erts: Minor spring cleaning

erts/emulator/beam/beam_common.c

@@ -406,9 +406,9 @@ Eterm error_atom[NUMBER_EXIT_CODES] = {
  *
  * This is needed to generate correct stacktraces when throwing errors from
  * instructions that return like an ordinary function, such as call_nif. */
-ErtsCodePtr erts_printable_return_address(Process* p, Eterm *E) {
-    Eterm *stack_bottom = STACK_START(p);
-    Eterm *scanner = E;
+ErtsCodePtr erts_printable_return_address(const Process* p, const Eterm *E) {
+    const Eterm *stack_bottom = STACK_START(p);
+    const Eterm *scanner = E;
 
     ASSERT(is_CP(scanner[0]));
 

erts/emulator/beam/beam_common.h

@@ -296,11 +296,13 @@ extern ErtsCodePtr beam_call_trace_return; /* OpCode(i_call_trace_return) */
  * @param[in] frame The frame to inspect. Must point at a CP.
  * @param[out] return_address The return address of \p frame */
 ERTS_GLB_INLINE
-const Eterm *erts_inspect_frame(Eterm *frame, ErtsCodePtr *return_address);
+const Eterm *erts_inspect_frame(const Eterm *frame,
+                                ErtsCodePtr *return_address);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 ERTS_GLB_INLINE
-const Eterm *erts_inspect_frame(Eterm *frame, ErtsCodePtr *return_address) {
+const Eterm *erts_inspect_frame(const Eterm *frame,
+                                ErtsCodePtr *return_address) {
     ASSERT(is_CP(frame[0]));
 
     if (ERTS_LIKELY(erts_frame_layout == ERTS_FRAME_LAYOUT_RA)) {

erts/emulator/beam/erl_io_queue.c

@@ -97,13 +97,13 @@ static ErtsIOQBinary *alloc_binary(Uint size, char *source, void **iov_base, int
     }
 }
 
-Uint erts_ioq_size(ErtsIOQueue *q)
+Uint erts_ioq_size(const ErtsIOQueue *q)
 {
     return q->size;
 }
 
 /* expand queue to hold n elements in tail or head */
-static int expandq(ErtsIOQueue* q, int n, int tail)
+static int expandq(ErtsIOQueue *q, int n, int tail)
 /* tail: 0 if make room in head, make room in tail otherwise */
 {
     int h_sz;  /* room before header */
@@ -376,8 +376,7 @@ int erts_ioq_deq(ErtsIOQueue *q, Uint size)
     return 0;
 }
 
-
-Uint erts_ioq_peekqv(ErtsIOQueue *q, ErtsIOVec *ev) {
+Uint erts_ioq_peekqv(const ErtsIOQueue *q, ErtsIOVec *ev) {
     ASSERT(ev);
 
     if (! q) {
@@ -396,7 +395,7 @@ Uint erts_ioq_peekqv(ErtsIOQueue *q, ErtsIOVec *ev) {
     }
 }
 
-SysIOVec* erts_ioq_peekq(ErtsIOQueue *q, int* vlenp)  /* length of io-vector */
+SysIOVec* erts_ioq_peekq(const ErtsIOQueue *q, int* vlenp) /* length of io-vector */
 {
 
     if (q == NULL) {

erts/emulator/beam/erl_io_queue.h

@@ -93,13 +93,13 @@ typedef struct erts_io_queue {
 
 void erts_ioq_init(ErtsIOQueue *q, ErtsAlcType_t alct, int driver);
 void erts_ioq_clear(ErtsIOQueue *q);
-Uint erts_ioq_size(ErtsIOQueue *q);
+Uint erts_ioq_size(const ErtsIOQueue *q);
 int erts_ioq_enqv(ErtsIOQueue *q, ErtsIOVec *vec, Uint skip);
 int erts_ioq_pushqv(ErtsIOQueue *q, ErtsIOVec *vec, Uint skip);
 int erts_ioq_deq(ErtsIOQueue *q, Uint Uint);
-Uint erts_ioq_peekqv(ErtsIOQueue *q, ErtsIOVec *ev);
-SysIOVec *erts_ioq_peekq(ErtsIOQueue *q, int *vlenp);
-Uint erts_ioq_sizeq(ErtsIOQueue *q);
+Uint erts_ioq_peekqv(const ErtsIOQueue *q, ErtsIOVec *ev);
+SysIOVec *erts_ioq_peekq(const ErtsIOQueue *q, int *vlenp);
+Uint erts_ioq_sizeq(const ErtsIOQueue *q);
 
 int erts_ioq_iolist_vec_len(Eterm obj, int* vsize, Uint* csize,
                             Uint* pvsize, Uint* pcsize,

erts/emulator/beam/erl_nif.c

@@ -424,10 +424,10 @@ int
 erts_call_dirty_nif(ErtsSchedulerData *esdp,
                     Process *c_p,
                     ErtsCodePtr I,
-                    Eterm *reg)
+                    const Eterm *reg)
 {
     int exiting;
-    ERL_NIF_TERM *argv = (ERL_NIF_TERM *) reg;
+    const ERL_NIF_TERM *argv = (const ERL_NIF_TERM *) reg;
     ErtsNativeFunc *nep = ERTS_I_BEAM_OP_TO_NFUNC(I);
     const ErtsCodeMFA *codemfa = erts_code_to_codemfa(I);
     NativeFunPtr dirty_nif = (NativeFunPtr) nep->trampoline.dfunc;
@@ -5372,14 +5372,14 @@ erts_nif_sched_init(ErtsSchedulerData *esdp)
     }
 }
 
-int erts_nif_get_funcs(struct erl_module_nif* mod,
+int erts_nif_get_funcs(const struct erl_module_nif* mod,
                        ErlNifFunc **funcs)
 {
     *funcs = mod->entry.funcs;
     return mod->entry.num_of_funcs;
 }
 
-Module *erts_nif_get_module(struct erl_module_nif *nif_mod) {
+Module *erts_nif_get_module(const struct erl_module_nif *nif_mod) {
     return nif_mod->mod;
 }
 

erts/emulator/beam/global.h

@@ -132,16 +132,16 @@ extern void erts_nif_sched_init(ErtsSchedulerData *esdp);
 extern void erts_nif_execute_on_halt(void);
 extern void erts_nif_notify_halt(void);
 extern void erts_nif_wait_calls(void);
-extern int erts_nif_get_funcs(struct erl_module_nif*,
+extern int erts_nif_get_funcs(const struct erl_module_nif*,
                               struct enif_func_t **funcs);
-extern Module *erts_nif_get_module(struct erl_module_nif*);
+extern Module *erts_nif_get_module(const struct erl_module_nif*);
 extern Eterm erts_nif_call_function(Process *p, Process *tracee,
                                     struct erl_module_nif*,
                                     struct enif_func_t *,
                                     int argc, Eterm *argv);
 
 int erts_call_dirty_nif(ErtsSchedulerData *esdp, Process *c_p,
-                        ErtsCodePtr I, Eterm *reg);
+                        ErtsCodePtr I, const Eterm *reg);
 ErtsMessage* erts_create_message_from_nif_env(ErlNifEnv* msg_env, Uint extra);
 
 
@@ -1216,7 +1216,8 @@ void erts_dirty_process_main(ErtsSchedulerData *);
 Eterm build_stacktrace(Process* c_p, Eterm exc);
 Eterm expand_error_value(Process* c_p, Uint freason, Eterm Value);
 void erts_save_stacktrace(Process* p, struct StackTrace* s);
-ErtsCodePtr erts_printable_return_address(Process* p, Eterm *E) ERTS_NOINLINE;
+ErtsCodePtr erts_printable_return_address(const Process* p,
+                                          const Eterm *E) ERTS_NOINLINE;
 
 /* erl_init.c */
 

erts/emulator/beam/jit/arm/beam_asm.hpp

@@ -1675,19 +1675,19 @@ class BeamModuleAssembler : public BeamAssembler,
         }
     }
 
-    enum Relation { none, consecutive, reverse_consecutive };
+    enum class Relation { none, consecutive, reverse_consecutive };
 
     static Relation memory_relation(const arm::Mem &mem1,
                                     const arm::Mem &mem2) {
         if (mem1.hasBaseReg() && mem2.hasBaseReg() &&
             mem1.baseId() == mem2.baseId()) {
             if (mem1.offset() + 8 == mem2.offset()) {
-                return consecutive;
+                return Relation::consecutive;
             } else if (mem1.offset() == mem2.offset() + 8) {
-                return reverse_consecutive;
+                return Relation::reverse_consecutive;
             }
         }
-        return none;
+        return Relation::none;
     }
 
     void flush_vars(const Variable<a64::Gp> &to1,

erts/emulator/beam/jit/arm/beam_asm_module.cpp

@@ -121,7 +121,7 @@ void BeamModuleAssembler::embed_vararg_rodata(const Span<ArgVal> &args,
 
         a.align(AlignMode::kData, 8);
         switch (arg.getType()) {
-        case ArgVal::Literal: {
+        case ArgVal::Type::Literal: {
             auto &patches = literals[arg.as<ArgLiteral>().get()].patches;
             Label patch = a.newLabel();
 
@@ -130,22 +130,22 @@ void BeamModuleAssembler::embed_vararg_rodata(const Span<ArgVal> &args,
             patches.push_back({patch, 0});
             break;
         }
-        case ArgVal::XReg:
+        case ArgVal::Type::XReg:
             data.as_beam = make_loader_x_reg(arg.as<ArgXRegister>().get());
             a.embed(&data.as_char, sizeof(data.as_beam));
             break;
-        case ArgVal::YReg:
+        case ArgVal::Type::YReg:
             data.as_beam = make_loader_y_reg(arg.as<ArgYRegister>().get());
             a.embed(&data.as_char, sizeof(data.as_beam));
             break;
-        case ArgVal::Label:
+        case ArgVal::Type::Label:
             a.embedLabel(rawLabels[arg.as<ArgLabel>().get()]);
             break;
-        case ArgVal::Immediate:
+        case ArgVal::Type::Immediate:
             data.as_beam = arg.as<ArgImmed>().get();
             a.embed(&data.as_char, sizeof(data.as_beam));
             break;
-        case ArgVal::Word:
+        case ArgVal::Type::Word:
             data.as_beam = arg.as<ArgWord>().get();
             a.embed(&data.as_char, sizeof(data.as_beam));
             break;
@@ -378,7 +378,7 @@ void BeamModuleAssembler::emit_aligned_label(const ArgLabel &Label,
 
 void BeamModuleAssembler::emit_i_func_label(const ArgLabel &Label) {
     flush_last_error();
-    emit_aligned_label(Label, ArgVal(ArgVal::Word, sizeof(UWord)));
+    emit_aligned_label(Label, ArgVal(ArgVal::Type::Word, sizeof(UWord)));
 }
 
 void BeamModuleAssembler::emit_on_load() {
@@ -775,11 +775,11 @@ void BeamModuleAssembler::emit_constant(const Constant &constant) {
         a.embedLabel(rawLabels.at(value.as<ArgLabel>().get()));
     } else {
         switch (value.getType()) {
-        case ArgVal::BytePtr:
+        case ArgVal::Type::BytePtr:
             strings.push_back({anchor, 0, value.as<ArgBytePtr>().get()});
             a.embedUInt64(LLONG_MAX);
             break;
-        case ArgVal::Catch: {
+        case ArgVal::Type::Catch: {
             auto handler = rawLabels[value.as<ArgCatch>().get()];
             catches.push_back({{anchor, 0, 0}, handler});
 
@@ -789,19 +789,19 @@ void BeamModuleAssembler::emit_constant(const Constant &constant) {
             a.embedUInt64(INT_MAX);
             break;
         }
-        case ArgVal::Export: {
+        case ArgVal::Type::Export: {
             auto index = value.as<ArgExport>().get();
             imports[index].patches.push_back({anchor, 0, 0});
             a.embedUInt64(LLONG_MAX);
             break;
         }
-        case ArgVal::FunEntry: {
+        case ArgVal::Type::FunEntry: {
             auto index = value.as<ArgLambda>().get();
             lambdas[index].patches.push_back({anchor, 0, 0});
             a.embedUInt64(LLONG_MAX);
             break;
         }
-        case ArgVal::Literal: {
+        case ArgVal::Type::Literal: {
             auto index = value.as<ArgLiteral>().get();
             literals[index].patches.push_back({anchor, 0, 0});
             a.embedUInt64(LLONG_MAX);

erts/emulator/beam/jit/arm/instr_bif.cpp

@@ -700,7 +700,7 @@ void BeamGlobalAssembler::emit_bif_nif_epilogue(void) {
         emit_enter_runtime();
 
         a.mov(ARG1, c_p);
-        runtime_call<ErtsCodePtr (*)(Process *, Eterm *),
+        runtime_call<ErtsCodePtr (*)(const Process *, const Eterm *),
                      erts_printable_return_address>();
 
         emit_leave_runtime();

erts/emulator/beam/jit/arm/instr_bs.cpp

@@ -2062,8 +2062,8 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgLabel &Fail,
         /* There is no way the call can fail on a 64-bit architecture. */
     } else if (estimated_num_bits <= ERL_ONHEAP_BITS_LIMIT) {
         static constexpr auto cur_bin_offset =
-                offsetof(ErtsSchedulerRegisters, aux_regs.d.erl_bits_state) +
-                offsetof(struct erl_bits_state, erts_current_bin);
+                offsetof(ErtsSchedulerRegisters,
+                         aux_regs.d.erl_bits_state.erts_current_bin);
         Uint need;
 
         arm::Mem mem_bin_base = arm::Mem(scheduler_registers, cur_bin_offset);
@@ -2566,7 +2566,7 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgLabel &Fail,
             break;
         case am_string: {
             ArgBytePtr string_ptr(
-                    ArgVal(ArgVal::BytePtr, seg.src.as<ArgWord>().get()));
+                    ArgVal(ArgVal::Type::BytePtr, seg.src.as<ArgWord>().get()));
 
             comment("insert string");
             ASSERT(seg.effectiveSize >= 0);

erts/emulator/beam/jit/arm/instr_call.cpp

@@ -36,7 +36,7 @@ void BeamGlobalAssembler::emit_dispatch_return() {
 void BeamModuleAssembler::emit_dispatch_return() {
 #ifdef JIT_HARD_DEBUG
     /* Validate return address and {x,0} */
-    emit_validate(ArgVal(ArgVal::Word, 1));
+    emit_validate(ArgVal(ArgVal::Type::Word, 1));
 #endif
 
     if (erts_alcu_enable_code_atags) {

erts/emulator/beam/jit/arm/instr_common.cpp

@@ -182,7 +182,7 @@ void BeamModuleAssembler::emit_validate(const ArgWord &Arity) {
     emit_enter_runtime_frame();
 
     for (unsigned i = 0; i < Arity.get(); i++) {
-        mov_arg(ARG1, ArgVal(ArgVal::XReg, i));
+        mov_arg(ARG1, ArgVal(ArgVal::Type::XReg, i));
 
         emit_enter_runtime();
         runtime_call<void (*)(Eterm), beam_jit_validate_term>();

erts/emulator/beam/jit/arm/instr_select.cpp

@@ -496,12 +496,12 @@ void BeamModuleAssembler::emit_i_jump_on_val(const ArgSource &Src,
     a.bind(data);
     if (embedInText) {
         for (const ArgVal &arg : args) {
-            ASSERT(arg.getType() == ArgVal::Label);
+            ASSERT(arg.getType() == ArgVal::Type::Label);
             a.embedLabel(rawLabels[arg.as<ArgLabel>().get()]);
         }
     }
 
-    if (Fail.getType() == ArgVal::Immediate) {
+    if (Fail.getType() == ArgVal::Type::Immediate) {
         a.bind(fail);
     }
 }

erts/emulator/beam/jit/arm/instr_trace.cpp

@@ -161,7 +161,7 @@ void BeamModuleAssembler::emit_return_trace() {
 
     emit_leave_runtime<Update::eHeapAlloc>(1);
 
-    emit_deallocate(ArgVal(ArgVal::Word, BEAM_RETURN_TRACE_FRAME_SZ));
+    emit_deallocate(ArgVal(ArgVal::Type::Word, BEAM_RETURN_TRACE_FRAME_SZ));
     emit_return();
 }
 
@@ -185,7 +185,8 @@ void BeamModuleAssembler::emit_i_call_trace_return() {
 
     emit_leave_runtime<Update::eHeapAlloc>(1);
 
-    emit_deallocate(ArgVal(ArgVal::Word, BEAM_RETURN_CALL_ACC_TRACE_FRAME_SZ));
+    emit_deallocate(
+            ArgVal(ArgVal::Type::Word, BEAM_RETURN_CALL_ACC_TRACE_FRAME_SZ));
     emit_return();
 }
 
@@ -203,7 +204,7 @@ void BeamModuleAssembler::emit_i_return_to_trace() {
 
     emit_leave_runtime<Update::eHeapAlloc>(1);
 
-    emit_deallocate(ArgVal(ArgVal::Word, BEAM_RETURN_TO_TRACE_FRAME_SZ));
+    emit_deallocate(ArgVal(ArgVal::Type::Word, BEAM_RETURN_TO_TRACE_FRAME_SZ));
     emit_return();
 }