Create an object at a given address: Difference between revisions

 

Data can be stored, one byte at a time, through the store instructions, for example to store data at $1900:

stx $1901

 

Storage can be indexed through the use of the X or Y registers:

.loop sta $1900,X

dex

 

It can also be stored via indirect indexed addressing (i.e. memory points to an address), using the Y register:

sta $70

lda #$20

sta $71

ldy #0

 

Finally, it can be stored via indexed indirect addressing (i.e. read the address of memory from the table stored at the parameter), using the X register:

sta $70

lda #$20

sta $71

ldx #0

 

It should be noted that on the 6502 processor hardware is normally memory mapped, so this is often used for manipulating hardware.

=={{header|68000 Assembly}}==

First, an integer object will be created at address $100000:

 

Finding the address of a given object isn't actually possible in the same way it would be on [[C]], since anything loaded from an address is just a numeric copy and is not actually related in any way to the "object." The closest way is to label a memory address and load that label as a numeric constant.

MOVE.L #myVariable,D0

 

Creating a new object at that location is as simple as storing a new value there.

 

=={{header|8086 Assembly}}==

This example uses UASM to assemble MS-DOS compatible code.

.stack 1024 ;set up stack

 

 

;get the address of a variable

 

=={{header|Action!}}==

DEFINE SECOND="54321"

 

PROC Main()

 

PrintF("Address of base variable: %H%E",@base)

PrintF("Value of base variable: %U%E",base)

PrintF("Value of copy variable: %U%E",copy)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_an_object_at_a_given_address.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

In [[Ada]] object address can be specified using the address representation clause [http://www.adaic.org/standards/05rm/html/RM-13-3.html RM 13.3]:

type IO_Port is mod 2**8; -- One byte

Device_Port : type IO_Port;

for Device_Port'Address use 16#FFFF_F000#;

In the example above the address is specified constant. It is also possible to specify address dynamically as the following solution of the task does:

with Ada.Text_IO; use Ada.Text_IO;

with System.Storage_Elements; use System.Storage_Elements;

Put_Line (Integer'Image (Y));

end Test_Address;

Sample output:

<pre>

=={{header|Aikido}}==

Aikido doesn't support getting the address of a variable. However, in the spirit of this task, it does support raw memory access using <code>peek</code> and <code>poke</code>. These can be used on both an integer representing an address (64 bit) or a value obtained from calling <code>malloc</code>.

 

var portaddr = 0x80

poke (addr+6, 12, 2)

 

=={{header|ARM Assembly}}==

{{trans|68000 Assembly}}

 

First, an integer object will be created at address $100000:

ldr r1,testData

str r1,[r0] ;store 0x12345678 at address $100000

 

testData:

 

Finding the address of a given object isn't actually possible in the same way it would be on [[C]], since anything loaded from an address is just a numeric copy and is not actually related in any way to the "object." The closest way is to label a memory address and load that label as a numeric constant.

mov r0,#myVariable

 

Creating a new object at that location is as simple as storing a new value there.

mov r1,#0

mvn r1,r1 ;flip the bits of r1

str r1,[r0] ;store 0xFFFFFFFF at address $100000

 

=={{header|AutoHotkey}}==

In AutoHotkey indeed no language objects can be created at a specified address. But it's very well possible to read and write memory addresses directly. All standard number types are allowed.

 

VarSetCapacity(var, 4, 0)

pAddress := &var

; Write a number and read it back.

NumPut(123456, pAddress+0, 0, "UInt")

 

=={{header|BBC BASIC}}==

anInteger% = 12345678

PRINT "Original value =", anInteger%

anInteger% = 55555555

PRINT "Final value =", !address%

Output:

<pre>Original value = 12345678

 

=={{header|C}}==

 

int main()

printf("%p: %08x (=%08x)\n", address, *address, intspace);

return 0;

 

<pre>0xbfc5675c: 0000ffff (=0000ffff)

 

A more typical embedded way of doing this is below. Note that the OS will probably not allow this due to memory protections. Embedded systems often do not have memory managers.

#include <stddef.h>

 

 

return 0;

 

=={{header|C++}}==

C++ supports this natively through placement new. This allows construction of complex object types in arbitrary memory locations.

#include <iostream>

 

stringPtr->~basic_string();

delete[] data;

 

Sample output:

 

=={{header|COBOL}}==

 

Output:

<pre>

</pre>

=={{header|Commodore BASIC}}==

The <code>PEEK</code> and <code>POKE</code> commands allow the [[Commodore BASIC]] user to perform limited [[6502 Assembly]] operations.

 

=={{header|D}}==

 

A better presentation.

 

void main() {

*fPtr = 0.5f ; // change value

writefln("arr[3] = 0x%8x (%9.4f) @ 0x%08X", *iPtr, *fPtr, iPtr) ;

output:

<pre>arr(as X)'s msg = '~~~A~~~B~~~C~~~D' (len 16) @ 0x401C2F80

</pre>

=={{header|Delphi}}==

program Create_an_object_at_a_given_address;

 

Readln;

 

{{out}}

<pre>The "origem" adress is: 4261256

=={{header|Forth}}==

As an untyped language, specific machine addresses are very easy to represent in Forth. This is usually most useful for embedded targets.

$3f8 constant LPT1:

 

LPT1: c@ .

$3f LPT1: c!

Some architectures may require special fetch and store operators to access ports. For example, [[Open Firmware]] defines l@ and l! for safe 32-bit port writes.

 

=={{header|FreeBASIC}}==

 

Type Person

Print

Print "Press any key to quit"

 

{{out}}

Teresa 60

</pre>

 

=={{header|Go}}==

Go has several ways to access arbitrary memory locations using the built-in unsafe package. If the desired memory contains an array, since Go doesn't have pointer arithmetic, then a slice should be used instead of a pointer. The following solution demonstrates both a pointer and a slice.

 

import(

 

slice()

Output:

<pre>

a: [65 32 115 116 114 105 110 103 46 0]

</pre>

 

=={{header|Julia}}==

address of a Julia integer variable within the VM may change when it is

re-assigned a new value, an array of a single integer is used below.

function unsafepointers()

intspace = [42]

 

unsafepointers()

{{output}}<pre>

The address of intspace is Ptr{Void} @0x0000000007271030

=={{header|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

import kotlinx.cinterop.*

with(intVar) { println("Value is $value, address is $rawPtr") }

nativeHeap.free(intVar)

 

{{out}}

Value is 42, address is 26431776

Value is 52, address is 26431776

</pre>

 

 

Memory addresses are nit the physical address, it's from virtual space.

Module CheckIt {

structure alfa {

}

Checkit

 

=={{header|Nim}}==

 

MyObject = object

x: int

objPtr[] = MyObject(x: 42, y: 3.1415)

echo "object at ", cast[int](mem), ": ", objPtr[]

 

Output:

This works for global variables too:

 

var p: ptr int

 

echo "Before ", x

p[] = 5

 

Output:

Like in Ada you can assigne different variables at the same adress of an already declared variable.

Nice to get the bytes out of an Int64.

type

t8Byte = array[0..7] of byte;

writeln(#8#32);

writeln(L);

4711

0 1 2 3 4 5 6 7

=={{header|Perl}}==

The is basically a simplified version of the solution to the [https://rosettacode.org/wiki/Address_of_a_variable#Perl Address of a variable] task, so for more detail please consult that entry.

 

use strict;

# print the value of this object to verify that it is same as one of the origin

 

{{out}}

<pre>

Phix does not support creation of a "language object" at a specific address, but you can peek and poke bytes, words, dwords and qwords

to any address, as long as doing so does not trigger a hardware exception. You could also use inline assembly, if that helps any.

<span style="color: #7060A8;">poke</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0x80</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">or_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">peek</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0x80</span><span style="color: #0000FF;">),</span><span style="color: #000000;">0x40</span><span style="color: #0000FF;">))</span>

#ilASM{ mov al,[0x80]

or al,0x40

mov [0x80],al}

 

=={{header|PicoLisp}}==

-> 12345

 

 

: IntSpace # Show the new value

 

=={{header|PureBasic}}==

; this address could be any number but it may then fail on some systems.

*a=AllocateMemory(1024*1024)

EndIf

Next

 

=={{header|Racket}}==

#lang racket

(require ffi/unsafe)

;; or start with a given address of something like a memory-mapped IO

;; object

 

=={{header|Raku}}==

(formerly Perl 6)

Raku has fairly comprehensive facilities for accessing allocating and accessing memory and also declaring C-style structs, via the NativeCall interface, as this example demonstrates.

use NativeCall::Types;

 

free($base-p);

done-testing;

{{out}}

<pre>creating object at address 94299589110352

=={{header|Rust}}==

In a real program, most if not all of the contents of main would all be in one `unsafe` block, however in this one each unsafe operation gets its own block to emphasize exactly which actions Rust considers unsafe.

 

fn main() {

println!("{0:p}: {0}", &data);

 

 

=={{header|Scala}}==

 

{{libheader|critcl}}

 

# A command to 'make an integer object' and couple it to a Tcl variable

# Conventionally, programs that use critcl structure in packages

# This is used to prevent recompilation, especially on systems like Windows

Demonstrating:

set addr [linkvar foo]

puts "var 'foo' at $addr with value $foo"

puts "var 'bar' at $addr with value $bar"

incr foo

Example output (your mileage may vary when it comes to addresses):

<pre>var 'foo' at 19363848 with value 0

Note that it is not possible to specify the address at which the embedding API function ''wrenSetSlotNewForeign'' allocates new objects and any attempt to allocate a new object at the same address as an old one by juggling with pointers will almost certainly lead to a seg fault. So all we can sensibly do is to change the value of the current object.

 

 

import "./fmt" for Fmt

Fmt.print("Integer object value reset to: $d but still at address $#x.", i.value, i.address)

i.value = 43

<br>

We now embed this in the following C program, compile and run it.

 

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

Integer object value changed to: 43 but still at address 0x55a56e0f2dd8.

</pre>

=={{header|Z80 Assembly}}==

When writing assembly yourself, you'll know any object's memory location in advance.

This code creates the 16-bit integer object 0xFFFF at memory address 0xC000:

 

Loading a value into a register from memory only loads a copy; the original value at that memory location isn't altered, nor is the memory location of that value. Assume this code is executed immediately after the above example:

INC HL ;HL now equals &0000

 

In order to change a value at a memory location, it either needs to be loaded into a register and stored back after altering that register in some way, or by using certain indirect addressing modes, like so:

INC (hl) ;increment the low byte.

 

If you're not familiar with the Z80's syntax, this can be a bit confusing. The brackets are like the dereference operator in C, and not having brackets is like the unary <code>&</code> operator in C. The Z80's ability to do 16-bit operations is limited; it can load from two consecutive memory locations into a 16-bit register pair, however when using <code>(hl)</code> as an operand it is only operating on the lower 8 bits. When learning Z80 Assembly, it is very helpful to view a hex editor while learning the instruction set.