std: unsafe-wrap personality::dwarf::eh · model-checking/verify-rust-std@6765b97 (original) (raw)

`@@ -70,45 +70,51 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result

70

71

`let func_start = context.func_start;

72

`let mut reader = DwarfReader::new(lsda);

73

-

74

let start_encoding = reader.read::();

75

// base address for landing pad offsets

76

let lpad_base = if start_encoding != DW_EH_PE_omit {

77

read_encoded_pointer(&mut reader, context, start_encoding)?

78

} else {

79

func_start

73

let lpad_base = unsafe {

74

let start_encoding = reader.read::();

75

// base address for landing pad offsets

76

if start_encoding != DW_EH_PE_omit {

77

read_encoded_pointer(&mut reader, context, start_encoding)?

78

} else {

79

func_start

80

}

80

81

`};

82

let call_site_encoding = unsafe {

83

let ttype_encoding = reader.read::();

84

if ttype_encoding != DW_EH_PE_omit {

85

// Rust doesn't analyze exception types, so we don't care about the type table

86

reader.read_uleb128();

87

}

81

88

82

let ttype_encoding = reader.read::();

83

if ttype_encoding != DW_EH_PE_omit {

84

// Rust doesn't analyze exception types, so we don't care about the type table

85

reader.read_uleb128();

86

}

87

-

88

let call_site_encoding = reader.read::();

89

let call_site_table_length = reader.read_uleb128();

90

let action_table = reader.ptr.add(call_site_table_length as usize);

89

reader.read::()

90

};

91

let action_table = unsafe {

92

let call_site_table_length = reader.read_uleb128();

93

reader.ptr.add(call_site_table_length as usize)

94

};

91

95

`let ip = context.ip;

92

96

93

97

`if !USING_SJLJ_EXCEPTIONS {

94

98

`// read the callsite table

95

99

`while reader.ptr < action_table {

96

// these are offsets rather than pointers;

97

let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;

98

let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;

99

let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;

100

let cs_action_entry = reader.read_uleb128();

101

// Callsite table is sorted by cs_start, so if we've passed the ip, we

102

// may stop searching.

103

if ip < func_start.wrapping_add(cs_start) {

104

break;

105

}

106

if ip < func_start.wrapping_add(cs_start + cs_len) {

107

if cs_lpad == 0 {

108

return Ok(EHAction::None);

109

} else {

110

let lpad = lpad_base.wrapping_add(cs_lpad);

111

return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));

100

unsafe {

101

// these are offsets rather than pointers;

102

let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;

103

let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;

104

let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;

105

let cs_action_entry = reader.read_uleb128();

106

// Callsite table is sorted by cs_start, so if we've passed the ip, we

107

// may stop searching.

108

if ip < func_start.wrapping_add(cs_start) {

109

break;

110

}

111

if ip < func_start.wrapping_add(cs_start + cs_len) {

112

if cs_lpad == 0 {

113

return Ok(EHAction::None);

114

} else {

115

let lpad = lpad_base.wrapping_add(cs_lpad);

116

return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));

117

}

112

118

113

119

114

120

`@@ -125,15 +131,15 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result

125

131

126

132

`let mut idx = ip.addr();

127

133

`loop {

128

let cs_lpad = reader.read_uleb128();

129

let cs_action_entry = reader.read_uleb128();

134

let cs_lpad = unsafe { reader.read_uleb128() };

135

let cs_action_entry = unsafe { reader.read_uleb128() };

130

136

` idx -= 1;

131

137

`if idx == 0 {

132

138

`// Can never have null landing pad for sjlj -- that would have

133

139

`// been indicated by a -1 call site index.

134

140

`// FIXME(strict provenance)

135

141

`let lpad = ptr::with_exposed_provenance((cs_lpad + 1) as usize);

136

return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));

142

return Ok(unsafe { interpret_cs_action(action_table, cs_action_entry, lpad) });

137

143

138

144

139

145

`@@ -151,9 +157,9 @@ unsafe fn interpret_cs_action(

151

157

`} else {

152

158

`// If lpad != 0 and cs_action_entry != 0, we have to check ttype_index.

153

159

`// If ttype_index == 0 under the condition, we take cleanup action.

154

let action_record = action_table.offset(cs_action_entry as isize - 1);

160

let action_record = unsafe { action_table.offset(cs_action_entry as isize - 1) };

155

161

`let mut action_reader = DwarfReader::new(action_record);

156

let ttype_index = action_reader.read_sleb128();

162

let ttype_index = unsafe { action_reader.read_sleb128() };

157

163

`if ttype_index == 0 {

158

164

`EHAction::Cleanup(lpad)

159

165

`} else if ttype_index > 0 {

`@@ -186,18 +192,20 @@ unsafe fn read_encoded_offset(reader: &mut DwarfReader, encoding: u8) -> Result<

186

192

`if encoding == DW_EH_PE_omit || encoding & 0xF0 != 0 {

187

193

`return Err(());

188

194

189

let result = match encoding & 0x0F {

190

// despite the name, LLVM also uses absptr for offsets instead of pointers

191

DW_EH_PE_absptr => reader.read::(),

192

DW_EH_PE_uleb128 => reader.read_uleb128() as usize,

193

DW_EH_PE_udata2 => reader.read::() as usize,

194

DW_EH_PE_udata4 => reader.read::() as usize,

195

DW_EH_PE_udata8 => reader.read::() as usize,

196

DW_EH_PE_sleb128 => reader.read_sleb128() as usize,

197

DW_EH_PE_sdata2 => reader.read::() as usize,

198

DW_EH_PE_sdata4 => reader.read::() as usize,

199

DW_EH_PE_sdata8 => reader.read::() as usize,

200

_ => return Err(()),

195

let result = unsafe {

196

match encoding & 0x0F {

197

// despite the name, LLVM also uses absptr for offsets instead of pointers

198

DW_EH_PE_absptr => reader.read::(),

199

DW_EH_PE_uleb128 => reader.read_uleb128() as usize,

200

DW_EH_PE_udata2 => reader.read::() as usize,

201

DW_EH_PE_udata4 => reader.read::() as usize,

202

DW_EH_PE_udata8 => reader.read::() as usize,

203

DW_EH_PE_sleb128 => reader.read_sleb128() as usize,

204

DW_EH_PE_sdata2 => reader.read::() as usize,

205

DW_EH_PE_sdata4 => reader.read::() as usize,

206

DW_EH_PE_sdata8 => reader.read::() as usize,

207

_ => return Err(()),

208

}

201

209

`};

202

210

`Ok(result)

203

211

`@@ -250,14 +258,14 @@ unsafe fn read_encoded_pointer(

250

258

`if encoding & 0x0F != DW_EH_PE_absptr {

251

259

`return Err(());

252

260

253

reader.read::<*const u8>()

261

unsafe { reader.read::<*const u8>() }

254

262

`} else {

255

let offset = read_encoded_offset(reader, encoding & 0x0F)?;

263

let offset = unsafe { read_encoded_offset(reader, encoding & 0x0F)? };

256

264

` base_ptr.wrapping_add(offset)

257

265

`};

258

266

259

267

`if encoding & DW_EH_PE_indirect != 0 {

260

ptr = *(ptr.cast::<*const u8>());

268

ptr = unsafe { *(ptr.cast::<*const u8>()) };

261

269

262

270

263

271

`Ok(ptr)