LLDB mainline
ProcessDebugger.cpp
Go to the documentation of this file.
1//===-- ProcessDebugger.cpp -----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "ProcessDebugger.h"
10
11// Windows includes
13#include <psapi.h>
14
21#include "lldb/Target/Process.h"
22#include "llvm/Support/ConvertUTF.h"
23#include "llvm/Support/Error.h"
24
25#include "DebuggerThread.h"
26#include "ExceptionRecord.h"
27#include "ProcessWindowsLog.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
32static DWORD ConvertLldbToWinApiProtect(uint32_t protect) {
33 // We also can process a read / write permissions here, but if the debugger
34 // will make later a write into the allocated memory, it will fail. To get
35 // around it is possible inside DoWriteMemory to remember memory permissions,
36 // allow write, write and restore permissions, but for now we process only
37 // the executable permission.
38 //
39 // TODO: Process permissions other than executable
40 if (protect & ePermissionsExecutable)
41 return PAGE_EXECUTE_READWRITE;
42
43 return PAGE_READWRITE;
44}
45
46// The Windows page protection bits are NOT independent masks that can be
47// bitwise-ORed together. For example, PAGE_EXECUTE_READ is not (PAGE_EXECUTE
48// | PAGE_READ). To test for an access type, it's necessary to test for any of
49// the bits that provide that access type.
50static bool IsPageReadable(uint32_t protect) {
51 return (protect & PAGE_NOACCESS) == 0;
52}
53
54static bool IsPageWritable(uint32_t protect) {
55 return (protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY |
56 PAGE_READWRITE | PAGE_WRITECOPY)) != 0;
57}
58
59static bool IsPageExecutable(uint32_t protect) {
60 return (protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE |
61 PAGE_EXECUTE_WRITECOPY)) != 0;
62}
63
64namespace lldb_private {
65
67
70 return m_session_data->m_debugger->GetProcess().GetProcessId();
72}
73
76 DebuggerThreadSP debugger_thread;
77 {
78 // Acquire the lock only long enough to get the DebuggerThread.
79 // StopDebugging() will trigger a call back into ProcessDebugger which will
80 // also acquire the lock. Thus we have to release the lock before calling
81 // StopDebugging().
82 llvm::sys::ScopedLock lock(m_mutex);
83
84 if (!m_session_data) {
85 LLDB_LOG(log, "there is no active session.");
86 return Status();
87 }
88
89 debugger_thread = m_session_data->m_debugger;
90 }
91
93
94 LLDB_LOG(log, "detaching from process {0}.",
95 debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
96 error = debugger_thread->StopDebugging(false);
97
98 // By the time StopDebugging returns, there is no more debugger thread, so
99 // we can be assured that no other thread will race for the session data.
100 m_session_data.reset();
101
102 return error;
103}
104
106 DebugDelegateSP delegate) {
107 // Even though m_session_data is accessed here, it is before a debugger
108 // thread has been kicked off. So there's no race conditions, and it
109 // shouldn't be necessary to acquire the mutex.
110
112 Status result;
113
114 FileSpec working_dir = launch_info.GetWorkingDirectory();
115 namespace fs = llvm::sys::fs;
116 if (working_dir) {
117 FileSystem::Instance().Resolve(working_dir);
118 if (!FileSystem::Instance().IsDirectory(working_dir)) {
119 result.SetErrorStringWithFormat("No such file or directory: %s",
120 working_dir.GetPath().c_str());
121 return result;
122 }
123 }
124
125 if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
126 StreamString stream;
127 stream.Printf("ProcessDebugger unable to launch '%s'. ProcessDebugger can "
128 "only be used for debug launches.",
129 launch_info.GetExecutableFile().GetPath().c_str());
130 std::string message = stream.GetString().str();
131 result.SetErrorString(message.c_str());
132
133 LLDB_LOG(log, "error: {0}", message);
134 return result;
135 }
136
137 bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
138 m_session_data.reset(new ProcessWindowsData(stop_at_entry));
139 m_session_data->m_debugger.reset(new DebuggerThread(delegate));
140 DebuggerThreadSP debugger = m_session_data->m_debugger;
141
142 // Kick off the DebugLaunch asynchronously and wait for it to complete.
143 result = debugger->DebugLaunch(launch_info);
144 if (result.Fail()) {
145 LLDB_LOG(log, "failed launching '{0}'. {1}",
146 launch_info.GetExecutableFile().GetPath(), result);
147 return result;
148 }
149
150 HostProcess process;
151 Status error = WaitForDebuggerConnection(debugger, process);
152 if (error.Fail()) {
153 LLDB_LOG(log, "failed launching '{0}'. {1}",
154 launch_info.GetExecutableFile().GetPath(), error);
155 return error;
156 }
157
158 LLDB_LOG(log, "successfully launched '{0}'",
159 launch_info.GetExecutableFile().GetPath());
160
161 // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the
162 // private state should already be set to eStateStopped as a result of
163 // hitting the initial breakpoint. If it was not set, the breakpoint should
164 // have already been resumed from and the private state should already be
165 // eStateRunning.
166 launch_info.SetProcessID(process.GetProcessId());
167
168 return result;
169}
170
172 const ProcessAttachInfo &attach_info,
173 DebugDelegateSP delegate) {
175 m_session_data.reset(
176 new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
177 DebuggerThreadSP debugger(new DebuggerThread(delegate));
178
179 m_session_data->m_debugger = debugger;
180
181 DWORD process_id = static_cast<DWORD>(pid);
182 Status error = debugger->DebugAttach(process_id, attach_info);
183 if (error.Fail()) {
184 LLDB_LOG(
185 log,
186 "encountered an error occurred initiating the asynchronous attach. {0}",
187 error);
188 return error;
189 }
190
191 HostProcess process;
192 error = WaitForDebuggerConnection(debugger, process);
193 if (error.Fail()) {
194 LLDB_LOG(log,
195 "encountered an error waiting for the debugger to connect. {0}",
196 error);
197 return error;
198 }
199
200 LLDB_LOG(log, "successfully attached to process with pid={0}", process_id);
201
202 // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the
203 // private state should already be set to eStateStopped as a result of
204 // hitting the initial breakpoint. If it was not set, the breakpoint should
205 // have already been resumed from and the private state should already be
206 // eStateRunning.
207
208 return error;
209}
210
213 DebuggerThreadSP debugger_thread;
214 {
215 // Acquire this lock inside an inner scope, only long enough to get the
216 // DebuggerThread. StopDebugging() will trigger a call back into
217 // ProcessDebugger which will acquire the lock again, so we need to not
218 // deadlock.
219 llvm::sys::ScopedLock lock(m_mutex);
220
221 if (!m_session_data) {
222 LLDB_LOG(log, "warning: state = {0}, but there is no active session.",
223 state);
224 return Status();
225 }
226
227 debugger_thread = m_session_data->m_debugger;
228 }
229
230 if (state == eStateExited || state == eStateDetached) {
231 LLDB_LOG(log, "warning: cannot destroy process {0} while state = {1}.",
232 GetDebuggedProcessId(), state);
233 return Status();
234 }
235
236 LLDB_LOG(log, "Shutting down process {0}.",
237 debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
238 auto error = debugger_thread->StopDebugging(true);
239
240 // By the time StopDebugging returns, there is no more debugger thread, so
241 // we can be assured that no other thread will race for the session data.
242 m_session_data.reset();
243
244 return error;
245}
246
250 llvm::sys::ScopedLock lock(m_mutex);
251 caused_stop = ::DebugBreakProcess(m_session_data->m_debugger->GetProcess()
252 .GetNativeProcess()
253 .GetSystemHandle());
254 if (!caused_stop) {
255 error.SetError(::GetLastError(), eErrorTypeWin32);
256 LLDB_LOG(log, "DebugBreakProcess failed with error {0}", error);
257 }
258
259 return error;
260}
261
262Status ProcessDebugger::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
263 size_t &bytes_read) {
265 bytes_read = 0;
267 llvm::sys::ScopedLock lock(m_mutex);
268
269 if (!m_session_data) {
270 error.SetErrorString(
271 "cannot read, there is no active debugger connection.");
272 LLDB_LOG(log, "error: {0}", error);
273 return error;
274 }
275
276 LLDB_LOG(log, "attempting to read {0} bytes from address {1:x}", size,
277 vm_addr);
278
279 HostProcess process = m_session_data->m_debugger->GetProcess();
280 void *addr = reinterpret_cast<void *>(vm_addr);
281 SIZE_T num_of_bytes_read = 0;
283 buf, size, &num_of_bytes_read)) {
284 error.SetError(GetLastError(), eErrorTypeWin32);
285 LLDB_LOG(log, "reading failed with error: {0}", error);
286 } else {
287 bytes_read = num_of_bytes_read;
288 }
289 return error;
290}
291
293 size_t size, size_t &bytes_written) {
295 bytes_written = 0;
297 llvm::sys::ScopedLock lock(m_mutex);
298 LLDB_LOG(log, "attempting to write {0} bytes into address {1:x}", size,
299 vm_addr);
300
301 if (!m_session_data) {
302 error.SetErrorString(
303 "cannot write, there is no active debugger connection.");
304 LLDB_LOG(log, "error: {0}", error);
305 return error;
306 }
307
308 HostProcess process = m_session_data->m_debugger->GetProcess();
309 void *addr = reinterpret_cast<void *>(vm_addr);
310 SIZE_T num_of_bytes_written = 0;
312 if (::WriteProcessMemory(handle, addr, buf, size, &num_of_bytes_written)) {
313 FlushInstructionCache(handle, addr, num_of_bytes_written);
314 bytes_written = num_of_bytes_written;
315 } else {
316 error.SetError(GetLastError(), eErrorTypeWin32);
317 LLDB_LOG(log, "writing failed with error: {0}", error);
318 }
319 return error;
320}
321
322Status ProcessDebugger::AllocateMemory(size_t size, uint32_t permissions,
323 lldb::addr_t &addr) {
327 llvm::sys::ScopedLock lock(m_mutex);
328 LLDB_LOG(log, "attempting to allocate {0} bytes with permissions {1}", size,
329 permissions);
330
331 if (!m_session_data) {
332 error.SetErrorString(
333 "cannot allocate, there is no active debugger connection");
334 LLDB_LOG(log, "error: {0}", error);
335 return error;
336 }
337
338 HostProcess process = m_session_data->m_debugger->GetProcess();
340 auto protect = ConvertLldbToWinApiProtect(permissions);
341 auto result = ::VirtualAllocEx(handle, nullptr, size, MEM_COMMIT, protect);
342 if (!result) {
343 error.SetError(GetLastError(), eErrorTypeWin32);
344 LLDB_LOG(log, "allocating failed with error: {0}", error);
345 } else {
346 addr = reinterpret_cast<addr_t>(result);
347 }
348 return error;
349}
350
352 Status result;
353
355 llvm::sys::ScopedLock lock(m_mutex);
356 LLDB_LOG(log, "attempting to deallocate bytes at address {0}", vm_addr);
357
358 if (!m_session_data) {
359 result.SetErrorString(
360 "cannot deallocate, there is no active debugger connection");
361 LLDB_LOG(log, "error: {0}", result);
362 return result;
363 }
364
365 HostProcess process = m_session_data->m_debugger->GetProcess();
367 if (!::VirtualFreeEx(handle, reinterpret_cast<LPVOID>(vm_addr), 0,
368 MEM_RELEASE)) {
369 result.SetError(GetLastError(), eErrorTypeWin32);
370 LLDB_LOG(log, "deallocating failed with error: {0}", result);
371 }
372
373 return result;
374}
375
377 MemoryRegionInfo &info) {
380 llvm::sys::ScopedLock lock(m_mutex);
381 info.Clear();
382
383 if (!m_session_data) {
384 error.SetErrorString(
385 "GetMemoryRegionInfo called with no debugging session.");
386 LLDB_LOG(log, "error: {0}", error);
387 return error;
388 }
389 HostProcess process = m_session_data->m_debugger->GetProcess();
391 if (handle == nullptr || handle == LLDB_INVALID_PROCESS) {
392 error.SetErrorString(
393 "GetMemoryRegionInfo called with an invalid target process.");
394 LLDB_LOG(log, "error: {0}", error);
395 return error;
396 }
397
398 LLDB_LOG(log, "getting info for address {0:x}", vm_addr);
399
400 void *addr = reinterpret_cast<void *>(vm_addr);
401 MEMORY_BASIC_INFORMATION mem_info = {};
402 SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
403 if (result == 0) {
404 DWORD last_error = ::GetLastError();
405 if (last_error == ERROR_INVALID_PARAMETER) {
406 // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with
407 // an address past the highest accessible address. We should return a
408 // range from the vm_addr to LLDB_INVALID_ADDRESS
409 info.GetRange().SetRangeBase(vm_addr);
415 return error;
416 } else {
417 error.SetError(last_error, eErrorTypeWin32);
418 LLDB_LOG(log,
419 "VirtualQueryEx returned error {0} while getting memory "
420 "region info for address {1:x}",
421 error, vm_addr);
422 return error;
423 }
424 }
425
426 // Protect bits are only valid for MEM_COMMIT regions.
427 if (mem_info.State == MEM_COMMIT) {
428 const bool readable = IsPageReadable(mem_info.Protect);
429 const bool executable = IsPageExecutable(mem_info.Protect);
430 const bool writable = IsPageWritable(mem_info.Protect);
432 info.SetExecutable(executable ? MemoryRegionInfo::eYes
435 } else {
439 }
440
441 // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
442 if (mem_info.State != MEM_FREE) {
443 info.GetRange().SetRangeBase(
444 reinterpret_cast<addr_t>(mem_info.BaseAddress));
445 info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) +
446 mem_info.RegionSize);
448 } else {
449 // In the unmapped case we need to return the distance to the next block of
450 // memory. VirtualQueryEx nearly does that except that it gives the
451 // distance from the start of the page containing vm_addr.
452 SYSTEM_INFO data;
453 ::GetSystemInfo(&data);
454 DWORD page_offset = vm_addr % data.dwPageSize;
455 info.GetRange().SetRangeBase(vm_addr);
456 info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
458 }
459
460 LLDB_LOGV(log,
461 "Memory region info for address {0}: readable={1}, "
462 "executable={2}, writable={3}",
463 vm_addr, info.GetReadable(), info.GetExecutable(),
464 info.GetWritable());
465 return error;
466}
467
468void ProcessDebugger::OnExitProcess(uint32_t exit_code) {
469 // If the process exits before any initial stop then notify the debugger
470 // of the error otherwise WaitForDebuggerConnection() will be blocked.
471 // An example of this issue is when a process fails to load a dependent DLL.
472 if (m_session_data && !m_session_data->m_initial_stop_received) {
473 Status error(exit_code, eErrorTypeWin32);
475 }
476}
477
479
482 const ExceptionRecord &record) {
484 llvm::sys::ScopedLock lock(m_mutex);
485 // FIXME: Without this check, occasionally when running the test suite
486 // there is an issue where m_session_data can be null. It's not clear how
487 // this could happen but it only surfaces while running the test suite. In
488 // order to properly diagnose this, we probably need to first figure allow the
489 // test suite to print out full lldb logs, and then add logging to the process
490 // plugin.
491 if (!m_session_data) {
492 LLDB_LOG(log,
493 "Debugger thread reported exception {0:x} at address {1:x}, but "
494 "there is no session.",
495 record.GetExceptionCode(), record.GetExceptionAddress());
496 return ExceptionResult::SendToApplication;
497 }
498
499 ExceptionResult result = ExceptionResult::SendToApplication;
500 if ((record.GetExceptionCode() == EXCEPTION_BREAKPOINT ||
501 record.GetExceptionCode() ==
502 0x4000001FL /*WOW64 STATUS_WX86_BREAKPOINT*/) &&
503 !m_session_data->m_initial_stop_received) {
504 // Handle breakpoints at the first chance.
505 result = ExceptionResult::BreakInDebugger;
506 LLDB_LOG(
507 log,
508 "Hit loader breakpoint at address {0:x}, setting initial stop event.",
509 record.GetExceptionAddress());
510 m_session_data->m_initial_stop_received = true;
511 ::SetEvent(m_session_data->m_initial_stop_event);
512 }
513 return result;
514}
515
517 // Do nothing by default
518}
519
520void ProcessDebugger::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {
521 // Do nothing by default
522}
523
525 lldb::addr_t module_addr) {
526 // Do nothing by default
527}
528
530 // Do nothing by default
531}
532
533void ProcessDebugger::OnDebugString(const std::string &string) {}
534
535void ProcessDebugger::OnDebuggerError(const Status &error, uint32_t type) {
536 llvm::sys::ScopedLock lock(m_mutex);
538
539 if (m_session_data->m_initial_stop_received) {
540 // This happened while debugging. Do we shutdown the debugging session,
541 // try to continue, or do something else?
542 LLDB_LOG(log,
543 "Error {0} occurred during debugging. Unexpected behavior "
544 "may result. {1}",
545 error.GetError(), error);
546 } else {
547 // If we haven't actually launched the process yet, this was an error
548 // launching the process. Set the internal error and signal the initial
549 // stop event so that the DoLaunch method wakes up and returns a failure.
550 m_session_data->m_launch_error = error;
551 ::SetEvent(m_session_data->m_initial_stop_event);
552 LLDB_LOG(log,
553 "Error {0} occurred launching the process before the initial "
554 "stop. {1}",
555 error.GetError(), error);
556 return;
557 }
558}
559
561 HostProcess &process) {
562 Status result;
564 LLDB_LOG(log, "Waiting for loader breakpoint.");
565
566 // Block this function until we receive the initial stop from the process.
567 if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) ==
568 WAIT_OBJECT_0) {
569 LLDB_LOG(log, "hit loader breakpoint, returning.");
570
571 process = debugger->GetProcess();
572 return m_session_data->m_launch_error;
573 } else
574 return Status(::GetLastError(), eErrorTypeWin32);
575}
576
577} // namespace lldb_private
static llvm::raw_ostream & error(Stream &strm)
ExceptionResult
Definition: ForwardDecl.h:16
static int ReadProcessMemory(uint8_t *buffer, size_t size, const pt_asid *, uint64_t pc, void *context)
Callback used by libipt for reading the process memory.
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:359
#define LLDB_LOGV(log,...)
Definition: Log.h:373
static bool IsPageExecutable(uint32_t protect)
static bool IsPageWritable(uint32_t protect)
static bool IsPageReadable(uint32_t protect)
static DWORD ConvertLldbToWinApiProtect(uint32_t protect)
lldb::addr_t GetExceptionAddress() const
A file utility class.
Definition: FileSpec.h:56
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
HostNativeProcessBase & GetNativeProcess()
Definition: HostProcess.cpp:36
lldb::pid_t GetProcessId() const
Definition: HostProcess.cpp:25
OptionalBool GetWritable() const
void SetMapped(OptionalBool val)
void SetReadable(OptionalBool val)
void SetExecutable(OptionalBool val)
void SetWritable(OptionalBool val)
OptionalBool GetReadable() const
OptionalBool GetExecutable() const
bool GetContinueOnceAttached() const
Definition: Process.h:148
Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)
Status DestroyProcess(lldb::StateType process_state)
Status LaunchProcess(ProcessLaunchInfo &launch_info, DebugDelegateSP delegate)
Status WaitForDebuggerConnection(DebuggerThreadSP debugger, HostProcess &process)
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info)
virtual void OnCreateThread(const HostThread &thread)
virtual void OnDebuggerError(const Status &error, uint32_t type)
virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
virtual void OnDebuggerConnected(lldb::addr_t image_base)
std::unique_ptr< ProcessWindowsData > m_session_data
Status AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr)
virtual void OnDebugString(const std::string &string)
virtual ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record)
Status AttachProcess(lldb::pid_t pid, const ProcessAttachInfo &attach_info, DebugDelegateSP delegate)
virtual void OnUnloadDll(lldb::addr_t module_addr)
lldb::pid_t GetDebuggedProcessId() const
Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
virtual void OnExitProcess(uint32_t exit_code)
virtual void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr)
Status HaltProcess(bool &caused_stop)
Status DeallocateMemory(lldb::addr_t addr)
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:70
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:43
const FileSpec & GetWorkingDirectory() const
An error handling class.
Definition: Status.h:44
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:246
bool Fail() const
Test for error condition.
Definition: Status.cpp:180
int void SetError(ValueType err, lldb::ErrorType type)
Set accessor with an error value and type.
Definition: Status.cpp:207
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:232
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:89
#define LLDB_INVALID_PROCESS
Definition: lldb-types.h:68
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
std::shared_ptr< IDebugDelegate > DebugDelegateSP
Definition: ForwardDecl.h:35
std::shared_ptr< DebuggerThread > DebuggerThreadSP
Definition: ForwardDecl.h:36
Definition: SBAddress.h:15
StateType
Process and Thread States.
@ eStateDetached
Process has been detached and can't be examined.
@ eStateExited
Process has exited and can't be examined.
@ eErrorTypeWin32
Standard Win32 error codes.
uint64_t pid_t
Definition: lldb-types.h:83
uint64_t addr_t
Definition: lldb-types.h:80
uint64_t tid_t
Definition: lldb-types.h:84
uint64_t process_t
Definition: lldb-types.h:57
void SetRangeEnd(BaseType end)
Definition: RangeMap.h:80
void SetRangeBase(BaseType b)
Set the start value for the range, and keep the same size.
Definition: RangeMap.h:48
void SetByteSize(SizeType s)
Definition: RangeMap.h:89