Segment Protection for Embedded Systems Using Run-time Checks

TargetSubtarget
div
rem
setcc
vsetcc
alloca
load
store
vgather
vimm
vscatter
getelementptr
phi
cast .. to
select
vselect
extract
extractelement
combine
combineelement
call
vaarg
bool, ubyte, sbyte, ushort, short, uint, int, ulong, long,

       float, double, pointer, 
-      packed
+  [ vector of <elementtype> ]
+
[vector of int]
[vector of float]
[vector of uint]
-  < <# elements> x <elementtype> >
+  [ vector of <# elements> <elementtype> ]

<4 x int>
<8 x float>
<2 x uint>
[vector of 4 int]
[vector of 8 float]
[vector of 2 uint]
<>
< int 42,
-  int 11, int 74, int 100 >
<>
< int 42, int 11, int 74, int 100 >
add
sub
mul
div
rem
setcc
label
array
structure
void
void
vsetcc
seteq
true
bool
vsetcc
  <result> = vseteq [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vseteq [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+  <result> = vsetne [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vsetne [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+  <result> = vsetlt [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vsetlt [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+  <result> = vsetgt [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vsetgt [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+  <result> = vsetle [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vsetle [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+  <result> = vsetge [vector of <ty>]   <var1>, <var2>   ; yields [vector of bool]
+  <result> = vsetge [vector of n <ty>] <var1>, <var2>   ; yields [vector of n bool]
+
vsetcc
vsetcc
vseteq
true
bool
vsetne
true
bool
vsetlt
true
bool
vsetgt
true
bool
vsetle
true
bool
vsetge
true
bool
  <result> = vseteq [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = false, false
+  <result> = vsetne [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = true, true
+  <result> = vsetlt [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = true, false
+  <result> = vsetgt [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = false, true
+  <result> = vsetle [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = true, false
+  <result> = vsetge [vector of 2 int] <int 4, int 5>, <int 5, int 4>      ; yields {[vector of 2 bool]}:result = false, true
+
load
  <result> = load <ty>* <pointer>
  <result> = volatile load <ty>* <pointer>

+  <result> = load <ty>* <pointer>
+  <result> = volatile load <ty>* <pointer>
+  <result> = aligned load <ty>* <pointer>
+
load
load
load
volatile
load
load
store
load
load
volatile
aligned
load
volatile
load
load
store
aligned
aligned load
load
  %ptr = alloca int                               ; yields {int*}:ptr
   store int 3, int* %ptr                          ; yields {void}
   %val = load int* %ptr                           ; yields {int}:val = int 3

aligned
load
store
  store <ty> <value>, <ty>* <pointer>                   ; yields {void}
-  volatile store <ty> <value>, <ty>* <pointer>                   ; yields {void}
+
++  store <ty> <value>, <ty>* <pointer>                      ; yields {void}
+  volatile store <ty> <value>, <ty>* <pointer>             ; yields {void}
+  aligned store <ty> <value>, <ty>* <pointer>              ; yields {void}

+
 Overview:
+
 The 'store' instruction is used to write to memory.
+
 Arguments:
-There are two arguments to the 'store' instruction: a value
-to store and an address to store it into.  The type of the '<pointer>'
-operand must be a pointer to the type of the '<value>'
-operand. If the store is marked as volatile, then the
-optimizer is not allowed to modify the number or order of execution of
-this store with other volatile load and store instructions.
+
+There are two arguments to the 'store' instruction: a
+value to store and an address to store it into.  The type of the
+'<pointer>' operand must be a pointer to the type of
+the '<value>' operand.  The store may be
+marked as volatile and/or aligned.
+
 Semantics:
-The contents of memory are updated to contain '<value>'
-at the location specified by the '<pointer>' operand.
+
+The contents of memory are updated to contain
+'<value>' at the location specified by the
+'<pointer>' operand.  If the store is marked
+as volatile, then the optimizer is not allowed to modify the
+number or order of execution of this store with other
+volatile load and store
+instructions.  An aligned store means that the pointer is
+guaranteed to satisfy the target architecture's alignment requirement
+for stores (if any), and that the store may be translated
+directly to a native store for the target.  Otherwise, the backend may
+have to perform an unaligned store or insert a runtime alignment
+correction, reducing efficiency.
+
 Example:
   %ptr = alloca int                               ; yields {int*}:ptr
   store int 3, int* %ptr                          ; yields {void}
   %val = load int* %ptr                           ; yields {int}:val = int 3

+
+TO DO:
+The aligned attribute is not yet implemented for store.
+
+
vgather
+  <result> = vgather <ty>* <pointer>{, <index group>, <multiplier>}+
+  <result> = aligned vgather <ty>* <pointer>{, <index group>, <multiplier>}+
+
<index group>
long <start>, long <end>, long <stride>
[vector of long]
vgather
vgather
(index group, multiplier)
index group
(start, end, stride)
multiplier
vgather
aligned
+  i = 0;
+  for each index I1 in index group 1
+    for each index I2 in index group 2
+      ...
+        for each index In in index group n
+	  result[i++] = pointer[I1 * multiplier1 + I2 * multiplier2 + ... + In * multipliern]
+
vgather
result
vgather
vgather
vgather
vgather
vgather
aligned
  %vec = vgather int* %ptr, long 0, long 9, long 1, long 1   ; yields {[vector of int]}:vec = ptr[0:9:1]
+  %vec = vgather int* %ptr, long 0, long 9, long 1, long 10, long 0, long 9, long 1, long 1   ; yields {[vector of int]}:vec = ptr[0:9:1][0:9:1]
+  %vec = vgather int* %ptr, [vector of long] %idx, long 1   ; yields{[vector of int]}:vec = ptr[idx]
+
aligned
vgather
[vector of long]
vimm
+  <result> = vimm <ty> <val>, uint <length>
+  <result> = fixed vimm <ty> <val>, uint <length>
+
vimm
vimm
fixed
fixed vimm
vimm
fixed
+vimm
+  %vec = vimm int 0, uint %n          ; yields [vector of int]
+  %vec = vimm int 0, uint 10          ; yields [vector of int]
+  %vec = fixed vimm int 0, uint 10    ; yields [vector of 10 int]
+
fixed vimm
vscatter
  <result> = vscatter [vector of <ty>] <value>, <ty>* <pointer>{, <index group>, <multiplier>}+
<index group>
long <start>, long <end>, long <stride>
[vector of long]
vscatter
vscatter
(index
+group, multiplier)
index group
(start, end, stride)
multiplier
vscatter
aligned
+  i = 0;
+  for each index I1 in index group 1
+    for each index I2 in index group 2
+      ...
+        for each index In in index group n
+	  pointer[I1 * multiplier1 + I2 * multiplier2 + ... + In * multipliern] = value[i++]
+
vscatter
vscatter
vscatter
vscatter
aligned
  vscatter [vector of int] %vec, int* %ptr, long 0, long 9, long 1, long 1   ; ptr[0:9:1] = {[vector of int]}:vec
+  vscatter [vector of int] %vec, int* %ptr, long 0, long 9, long 1, long 10, long 0, long 9, long 1, long 1   ; ptr[0:9:1][0:9:1] = {[vector of int]}:vec
+  vscatter [vector of int] %vec, int* %ptr, [vector of long] %idx, long 1   ; ptr[idx] = {[vector of int]}:vec
+
aligned
vscatter
[vector of long]
getelementptr
vselect
+  <result> = vselect [vector of bool]   <cond>, [vector of <ty>]   <val1>, [vector of <ty>]   <val2> ; yields [vector of <ty>]
+  <result> = vselect [vector of n bool] <cond>, [vector of n <ty>] <val1>, [vector of n <ty>] <val2> ; yields [vector of n <ty>]
+
vselect
vselect
+  %X = vselect bool [vector of 2 bool] <bool true, bool false>, [vector of 2 ubyte] <ubyte 17, ubyte 17>, 
+    [vector of 2 ubyte] <ubyte 42, ubyte 42>      ; yields [vector of 2 ubyte]:17, 42
+
extract
+  <result> = extract [vector of <ty>] <val>, uint <start>, uint <stride>, uint <length>   ; yields [vector of <ty>]
+  <result> = extract [vector of n <ty>] <val>, uint <start>, uint <stride>, uint <length>   ; yields [vector of <ty>]
+  <result> = fixed extract [vector of <ty>] <val>, uint <start>, uint <stride>, uint <length>   ; yields [vector of n <ty>]
+  <result> = fixed extract [vector of n <ty>] <val>, uint <start>, uint <stride>, uint <length>   ; yields [vector of n <ty>]
+
extract
extract
vimm
fixed
fixed vimm
extract
fixed
+extract
val
length
length
start
val
stride
start + stride * length
val
+  %result = extract [vector of int]    %vec, uint 0, uint 9, uint 2    ; yields [vector of int]
+  %result = extract [vector of 10 int] %vec, uint 0, uint 9, uint 2    ; yields [vector of 10 int]
+
fixed
extract
extract
fixed
fixed
extractelement
+  <result> = extractelement [vector of <ty>]   <val>, uint <idx>    ; yields <ty>
+  <result> = extractelement [vector of n <ty>] <val>, uint <idx>    ; yields <ty>
+
extractelement
extract
val
idx
val
idx
val
+  %result = extractelement [vector of int]    %vec, uint 0    ; yields int
+  %result = extractelement [vector of 10 int] %vec, uint 0    ; yields int
+
combine
+  <result> = combine [vector of <ty>]   <val1>, [vector of <ty>],   <val2>, uint <start>, uint <stride>   ; yields [vector of <ty>]
+  <result> = combine [vector of n <ty>] <val2>, [vector of n <ty>], <val2>, uint <start>, uint <stride>   ; yields [vector of n <ty>]
+
combine
combine
val1
val1
start
stride
val2
val2
val2
stride
start
val1
+  %result = combine [vector of int]    %v1, [vector of int]    %v2, uint 0, uint 9    ; yields [vector of int]
+  %result = combine [vector of 10 int] %v1, [vector of 10 int] %v2, uint 0, uint 9    ; yields [vector of 10 int]
+
combineelement
+  <result> = combineelement [vector of <ty>]   <val>, <ty> <elt>, uint <idx>    ; yields [vector of <ty>]
+  <result> = combineelement [vector of n <ty>] <val>, <ty> <elt>, uint <idx>    ; yields [vector of n <ty>]
+
combineelement
combineelement
val
val
idx
elt
idx
val
+  %result = combineelement [vector of int]    %vec, int 5, uint 0    ; yields [vector of int]
+  %result = combineelement [vector of 10 int] %vec, int 5, uint 0    ; yields [vector of 10 int]
+
permute
+  <result> = permute [vector of <ty>] <val>, [vector of uint] <idx>    ; yields [vector of <ty>]
+  <result> = permute [vector of n <ty>] <val>, [vector of n uint] <idx>    ; yields [vector of n <ty>]
+
permute
permute
uint
val
val
i
j
val
j
i
idx
idx
val
+  %result = permute [vector of 4 int] <int 1, int 2, int 3, int 4>, 
+    [vector of uint] <uint 4, uint 3, uint 2, uint 1>
+  ; yields [vector of 4 int] <int 4, int 3, int 2, int 1>
+
permute
http://llvm.cs.uiuc.edu/
-cee, -branch-combine, -instloops, -paths, -pre
-cee, -pre
llvm-db
-cee, -pre
llvm-db
-regalloc=iterativescan

Overview:

Syntax:

Examples:

Overview:

Syntax:

Arguments:

Semantics:

Semantics:

Semantics:

Semantics:

Semantics:

Semantics:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Examples:

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Example:

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Examples (Using Fortran 90-Style Notation):

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Examples:

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Examples (Using Fortran 90-Style Notation):

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

TO DO:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

TO DO:

Abstract: