Create an object at a given address: Difference between revisions

{{task|Basic Data Operations}}

{{basic data operation}}

In systems programing it is sometimes required to place language objects at specific memory locations, like I/O registers, hardware interrupt vectors etc.

 

 

Show how language objects can be allocated at a specific machine addresses.

 

 

 

 

In [[6502 Assembly]] memory is represented by either an 8-bit or a 16-bit address (i.e. $0000 - $FFFF). 8-bit address are reserved for the memory from $00 to $FF - known as zero page; access to this memory takes one less byte in the opcode and one less cycle to execute.

 

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.

 

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>

456

</pre>

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|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|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

arr[3] = 0x3f000000 ( 0.5000) @ 0x401C2F8C

</pre>

 

=={{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 52, address is 26431776

</pre>

=={{header|M2000 Interpreter}}==

In M2000 we can create two kind of buffers, one for data, and one for code. Buffer for code is immutable at execution time. We can execute code by using an offset. Buffer for data is always mutable, but can't execute code.

 

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

Module CheckIt {

structure alfa {

}

Checkit

 

 

=={{header|Pascal}}==

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

506097522914230528</pre>

=={{header|Phix}}==

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.

 

=={{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|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}}==

 

It is rather unprofessional to deliver this kind of error-prone software. And we are wondering why this tasks is made.

=={{header|Tcl}}==

As noted in the [[Address Operations]] task, it is highly unusual to work with low-level addresses in Tcl. However it is possible to use Tcl's [[C]] API (specifically <code>[http://www.tcl.tk/man/tcl8.6/TclLib/LinkVar.htm Tcl_LinkVar]</code>) to couple Tcl variables to a particular address:

 

{{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

var 'bar' at 19363848 with value 0

incremented 'foo' so 'bar' is 1</pre>

 

{{omit from|AWK}}

{{omit from|JavaScript}}

{{omit from|Joy}}

{{omit from|Logtalk}}

{{omit from|M4}}

{{omit from|Oz}}

{{omit from|PARI/GP}}

{{omit from|PowerShell}}

{{omit from|Python}}

{{omit from|Ruby}}